table 69x6

import java.util.*;
import java.io.*;


public class testingsolution2 {
    public static int nVolte;
    public static int X = 69;
    public static int Y = 6;
    public static int RIP = 9;
    public static int MAX = 46;
    public static int[][] sudoku = new int[Y][X];
    public static int[][] controlli = new int[MAX+1][MAX+1];
    public static int[][] appoggioscambio = new int[X][2];
    public static int[] vett = new int[Y*X];
    public static Scanner sc = new Scanner(System.in);
    public static int imax = 370;
    public static int imin = 377;



    public static void main (String args[]) {
        Random rgen = new Random();  // Random number generator

        boolean messo, presente, possibile;
        int n,c2;
        long ciclo=0;
        c2=0;


        //riempio
        for (int i=0; i<MAX; i++) {
            for (int j=0; j<RIP; j++){
            vett[c2] = (i+1);
            c2++;
            }
        }

        //--- Shuffle by exchanging each element randomly
        for (int i=0; i<vett.length; i++) {
            int randomPosition = rgen.nextInt(vett.length);
            int temp = vett[i];
            vett[i] = vett[randomPosition];
            vett[randomPosition] = temp;
        }

        //inizializzo sudoku con tutti i valori a -1
        for (int i=0; i<X; i++) {
            for (int j=0; j<Y; j++) {
                sudoku[j][i] = -1;
            }
        }

        //inizializzo controlli, 0 = da mettere, 1 = da non mettere
        for (int i=1; i<MAX; i++) {
            for (int j=1; j<MAX; j++) {
                if(i==j) controlli[j][i] = 1;
                else controlli[j][i] = 0;
            }
        }
        System.out.println("Finito inizializzazione");

        //inserimento
        for (int i=0; i<(Y*X); i++){
            if(i>imax){
                stampa("tabella_imax" + i, i);
                imax = i;
            }
            System.out.println("Progresso: " + i + " su: " + ((Y*X)-1) + " ciclo: " + ciclo);
            ciclo++;
            //controllo(i);
            presente = true;
            messo = false;
            n=0;//orizzonatale



            //controllo se gia presente in colonna

            while(messo == false){
                //System.out.println("inizio while n=" +n);
                //controllo se c'e' uno spazio
                possibile = controllospazio(n);
                if(possibile == false) n++;
                else{
                    //System.out.println("possibile");
                    //controllo se posso mettere vett[i] assieme a tutti gli altri valori nella colonna n
                    presente = controllovalore(n, vett[i]); // ritorna vero se il valore e' gia combaciato con altri valori, falose se no (indi posso metterlo in quella colonna)

                    //inserisco un numero vett[i] (m) nella tabella alla colonna n e cambio i controlli
                    if(presente == false){
                        messo = inseriscovalore(n, vett[i]); // ritorna vero se inserito falso se non inserito
                    }

                    //non presente, no posti liberi
                    if(messo == false) n++;
                }//end else possibile

                //se raggiungo ultima colonna inizio a scambiare
                if(n==X){
                    //prima di iniziare lo scambio controllo se ci sono altri numeri da isnerite
                    for(int i1 = (i+1); i1<(X*Y); i1++){
                        for(int n1 = 0; n1<X; n1++){ // per ogni colonna
                            if(controllospazio(n1)){ //ritorna vero se c'e' uno spazio vuoto in quella colonna
                                if(!controllovalore(n1, vett[i1])){ //ritorna falso se non combacia
                                    inseriscovalore(n1, vett[i1]); // inserisce
                                    //riordina array (sposta avanti da i a i1 tutti i valori, poi scala i di 1
                                    for(int j = i1; j>i; j--){
                                        vett[j]=vett[j-1];
                                    }
                                    i++;
                                }
                            }
                        }
                    }
                    //se ho piu di 380 numeri insiriti inizia a testare tutte le colonne
                    //scambia
//                  System.out.println("scambio " + vett[i]);
                    i = scambio(vett[i], i);

                    break;
                }
            }   //end while presente

        }   //end for inserimento
        System.out.println("end for inserimento");
        stampa("tabella_finita", 413);
    }//end esegui


    //output to file
    public static void stampa(String nome, int pos){
        try{

            new File("N:/Tabelle").mkdirs();
              // Create file
                PrintWriter out = new PrintWriter(new FileWriter("N:\\Tabelle\\" + nome +".txt"));
              for(int c=0;c<Y;c++){
                  for(int d=0; d<X;d++){
                  out.print(sudoku[c][d] + "\t");
                  }
                  out.println("");
              }
              out.println("num non ancora inseriti");
              for(int i=pos; i<(X*Y); i++){
                  out.print(vett[i] + "\t");
              }
              out.println();
              out.println("\n Tabella match");
              for(int i = 0; i<=MAX; i++){
                  for(int j = 0; j<=MAX; j++){
                      if(i==0) out.print(j + "\t");
                      else if(j==0) out.print(i + "\t");
                      else out.print(controlli[i][j] + "\t");
                  }
                  out.println();
              }
              //Close the output stream
              out.close();
              }catch (Exception e){//Catch exception if any
              System.err.println("Error: " + e.getMessage());
              }

    }   //end stampa


    //controllospazio
    public static boolean controllospazio(int n){

        boolean possibile = false;
        for(int i = 0; i<Y; i++){
            if(sudoku[i][n]==-1) possibile = true;
        }
        return possibile;
    }


    //controllo se posso mettere vett[i] (m) assieme a tutti gli altri valori nella colonna n
    public static boolean controllovalore(int n, int m){

        boolean presente = false;
        for(int i = 0; i<Y; i++){
            if(sudoku[i][n]==-1) presente = false;
            else if(controlli[sudoku[i][n]][m]==1) {
                presente = true;
                break;
            }
        }
        return presente;
    }


    //inserisco un numero vett[i] (m) nella tabella alla colonna n e cambio i controlli
    public static boolean inseriscovalore(int n, int m){
//      System.out.println("inserisco= " + m);
        boolean inserito = false;
        for(int i = 0; i<Y; i++){
            if(sudoku[i][n]==-1){
                sudoku[i][n]=m;
                inserito = true;
                //modifico i controlli
                for(int j = 0; j<Y; j++){
                    if(sudoku[j][n]!=-1) {
                        controlli[sudoku[j][n]][m]=1;
                        controlli[m][sudoku[j][n]]=1;
                    }
                }
                break;
            }
        }
        return inserito;
    }



    //scambio, controllo una alla volta tutte le colonne alla ricerca di un buon posto per inserire il valore
    //salvo il numero di match per ogni colonna e scelgo a random tra le piu corte
    //tolgo tutti i valori che fanno match e inserisco il valore iniziale senza posto, aggiorno i e inserisco i valori nel vettore
    //ritorna la nuova posizione di i
        //problema: continua a scambiare gli stessi 2 numeri. possibile soluzione:
            //rendere una colonna "non scambiabile" per tot cicli
            //
    public static int scambio(int m, int pos){
//      System.out.println("inizio scambio. i= " + pos + " m: " + m);

        //inizzializza il valore di appoggio
        for(int i = 0; i<X; i++){
            appoggioscambio[i][0]=100;
            appoggioscambio[i][1]=i;
        }
        //inizio i controlli
        for(int i = 0; i<X; i++){
            //controllo ogni colonna
            for(int j = 0; j<Y; j++){
                //controllo ogni riga
                if(sudoku[j][i]!=-1){
                    if(controlli[sudoku[j][i]][m]==1 && sudoku[j][i] != m){
                        if(appoggioscambio[i][0] == 100) appoggioscambio[i][0] = 0;
                        appoggioscambio[i][0]++;
                    }
                    if(sudoku[j][i] == m){
                        appoggioscambio[i][0]=appoggioscambio[i][0]+7;
//                      System.out.print("trovato se stesso in col " + i + " ");
                    }
                }
            }

        }//fine controlli tabella, appoggioscambio ha dentro tutti i numeri di match
        //ordina i match

        appoggioscambio = Sort(appoggioscambio);

        //trovo quante colonne hanno il num minore di match
        int contatore = 0;
        for(int i = 0; i<X; i++){
            if(appoggioscambio[i][0]==appoggioscambio[0][0]) contatore++;
            else break;
        }

        //sceglio a caso una di quelle colonne
        Random rgen = new Random();
        int rndCol = rgen.nextInt(contatore);
        boolean trovato = false;
        int rimossi = 0;
        int colx = 0;
        while(!trovato){
        //rimuovo match dalla colonna
        rndCol = rgen.nextInt(contatore);
        rimossi = 0;
        colx = appoggioscambio[rndCol][1];
        if(appoggioscambio[rndCol][0]<7 && appoggioscambio[rndCol][0]>0){
//          System.out.print(" - scelto colonna: " + colx);
            for(int j=0; j<Y;j++){
                if(sudoku[j][colx]!=-1){
                    if(controlli[sudoku[j][colx]][m]==1 && sudoku[j][colx]!=m){
                        //riinserisco il num che sto x rimuovere nel vettore dei num da inserire
                        //in coda

                        for(int k = pos-10; k<((X*Y)-1); k++){
                            vett[k] = vett[k+1];
                        }
                        vett[(X*Y)-1]=sudoku[j][colx];

//                      System.out.println("- rimuovo: " + sudoku[j][colx]);
                        //sistemo i controlli
                        for(int i = 0; i<Y; i++){
                            if(sudoku[i][colx]!=-1 && sudoku[j][colx]!=-1 && sudoku[i][colx]!=sudoku[j][colx]) {
                                controlli[sudoku[j][colx]][sudoku[i][colx]]=0;
                                controlli[sudoku[i][colx]][sudoku[j][colx]]=0;
                            }
                        }
                        //rimuovo il numero
                        sudoku[j][colx]=-1;
                        rimossi++;
                    }
                }
            }
        trovato = true;
        }
        }
        //inserisco valore nella colonna
        inseriscovalore(colx, m);
//      System.out.println("fine scambio. appoggioscambio= " + appoggioscambio[rndCol][0] + "/" + rimossi );
        return (pos - rimossi);
    }

    //sort
    public static int[][] Sort(int[][] data){
        for(int i = 0; i < X; i++) {
            boolean flag = false;
            for(int j = 0; j < X-1; j++) {
                //Se l' elemento j e maggiore del successivo allora
                //scambiamo i valori
                if(data[j][0]>data[j+1][0]) {
                    int k = data[j][0];
                    int k2 = data[j][1];
                    data[j][0] = data[j+1][0];
                    data[j][1] = data[j+1][1];
                    data[j+1][0] = k;
                    data[j+1][1] = k2;
                    flag=true; //Lo setto a true per indicare che é avvenuto uno scambio
                }


            }

            if(!flag) break; //Se flag=false allora vuol dire che nell' ultima iterazione
                             //non ci sono stati scambi, quindi il metodo può terminare
                             //poiché l' array risulta ordinato
            }

          return data;
        }

    //controllo di -1
    public static void controllo(int pos){
        int c =0;
        for(int i = 0; i<X; i++){
            for(int j = 0; j<Y; j++){
                if(sudoku[j][i]==-1) c++;
            }
        }
        if(c!=(414 - pos)){
            System.out.println("\nerrore numero di -1: " + c + " num do numeri da inserire: " + (414 - pos));
            sc.nextLine();
        }
    }


}   //end class