Beispiel #1
0
/********************************************************************
  Funzione ricorsiva di ricerca di una soluzione
********************************************************************/
int trova(int **schema, int dim, int passo)
{
   int i, j, k;

   /* verifica di terminazione */
   if (passo >= dim*dim) {
      return 1;
   }

   /* indici casella corrente */
   i = passo / dim;
   j = passo % dim;
   if (schema[i][j] != 0) {
      /* casella inizialmente piena: nessun tentativo da fare */
      return trova(schema, dim, passo+1);
   }

   /* provo tutti i possibili valori da 1 a dim */
   for (k=1; k<=dim; k++) {
      schema[i][j] = k;
      if (controlla(schema, dim, passo)) {
	     if (trova(schema, dim, passo+1)) {
	        return 1;
         }
      }
      schema[i][j] = 0;
   }

   return 0;
}
Beispiel #2
0
main()
{
 strcpy(status.nomefile,"base.idl");
 inizializza();
 setmenuP(0," Files ",1,hh);
 setmenuP(0," Compile ",1,menuto2);
 setmenuP(0," Quit! ",1,esci);
 setmenuS(0,1," Ciao ",1,hh);
 setmenuS(0,1," Addio ",1,gg);
 gwindow(60,60,300,200," Main Win ",12,1,14,3);
 num=status.active_window;
 perc_init();
 for(x=0;x<=37;x++)
 {
  percent(x,37);
 }
 perc_end();
 mouse(1);
 while(kd!=27)
 {
  while((kd=ikey())==0) {}
  controlla(kd);
  x=contr_drives();
  if(x!=-1) {setdisk(x);dato=x;}
 }
 mouse(2);
 nogwin();
 finisci();
 return(0);
}
Beispiel #3
0
int disp_ripet(rules **tb, int dim, int pos)
{
    int i, j, k;
    
    if(pos>=dim*dim)
    {
        stampa_schema(tb, dim);
        return 1;
    }
    
    i=pos/dim;
    j=pos%dim;
    
    if(tb[i][j].V!=0)
        return(disp_ripet(tb, dim, pos+1));
    
    for(k=1;k<=dim;k++)
    {
        tb[i][j].V=k;
        if(controlla(tb, dim, pos))
            if(disp_ripet(tb, dim, pos))
                return 1;
        tb[i][j].V=0;
    }
    return 0;
}
Beispiel #4
0
/*Minimax*/
int minimax(int giocatore, int profondita) {
    if(controlla(2))
        return INT_MAX;
    if(controlla(1)==-1)
        return INT_MIN;
    int res,tmp;
    if(giocatore==1) {
        res=1;
        for(i=0; i<M; i++) {
            for(k=0; k<M; k++) {
                if(!tabella[i][k]) {
                    tabella[i][k]=1;
                    if(controlla(1)) {
                        if(profondita==20) {
                            tabella[i][k]=0;
                            return INT_MIN;
                        }
                        else
                            res-=2;
                    }
                    else if(((tmp=minimax(2,profondita-1))<res) || (tmp==INT_MIN))
                        res=tmp;
                    tabella[i][k]=0;
                }
            }
        }
    }
    else {
        res=-1;
        for(i=0; i<M; i++) {
            for(k=0; k<M; k++) {
                if(!tabella[i][k]) {
                    tabella[i][k]=2;
                    if(controlla(2))
                        res+=2;
                    else if(((tmp=minimax(1,profondita-1))>res) || (tmp==INT_MAX))
                        res=tmp;
                    tabella[i][k]=0;
                }
            }
        }
    }
    return res;
}
Beispiel #5
0
int controlla(int **M,int inizio,int g,int flag)
{
    int i,j;

    if(inizio == g-1 && flag == M[inizio][g-1])
        return 0;

    for(i=inizio,j=inizio; i <= g-1, j<=g-2; i++,j++)
        if(M[inizio][i] != M[g-1][i] || M[inizio][i] != flag && M[j][inizio] != M[j][g-1] || M[j][inizio] != flag)
            return 1;

    if(controlla(M,inizio+1,g-1,!flag) == 0)
        return 0;
}
Beispiel #6
0
int main()
{
    int grande,
        i,j;
    int **M;

    printf("Quanto deve essere grande la matrice?\nRis: ");
    scanf("%d",&grande);
    
    M = (int**)malloc(grande*sizeof(int*));

    for(i=0;i < grande; i++)
    {
        M[i] = (int*)malloc(grande*sizeof(int));
        for(j=0; j < grande; j++)
        {
            printf("Inserisci[%d][%d]: ",i,j);
            scanf("%d",&M[i][j]);
            if(M[i][j] != 0 && M[i][j] != 1)
            {
                printf("Deve essere una matrice binaria!\n");
                return -1;
            }
        }

    }

    stampa_M(M,grande);

    if(controlla(M,0,grande,0) == 1)
        puts("La matrice NON è costituita da una cornice di 0 alternati ad 1");
    else
        puts("La matrice e' costituita da una cornice di 0 alternati ad 1");

    return 0;
}
Beispiel #7
0
int main()
{
   FILE *file;                              
   file=fopen("input.txt", "r");               // I N P U T
   fscanf(file, "%d", &N);
   petali=(int *)malloc(N*sizeof(int));     
   for(int pet=0; pet < N; pet++)
   {
       int col;
       fscanf(file, "%d", &col);     
       petali[pet]=col;
       quanti[col]++;
   }
   fclose(file);
   
   for(int col=1; col <= COLORI; col++)
       collane[col]=(int *)malloc(quanti[col]*sizeof(int));

   int posizione[COLORI+1];
   for(int col=1; col <= COLORI; col++)
       posizione[col]=0;
   for(int pet=0; pet < N; pet++)
   {
       int col=petali[pet];
       collane[col][posizione[col]]=pet;
       posizione[col]++;
   }
/*
   for(int col=1; col <= COLORI; col++)
   {
      if(quanti[col] != 0)
      {
          printf("%2d: ", col);
          for(int pet=0; pet < quanti[col]; pet++)
             printf("%d ", collane[col][pet]);   
          printf("\n");   
      }
   }
*/  
   int risposta=0;                             // ELABORAZIONE
   for(int col=1; col <= COLORI; col++)
   {
      int quanti_c=quanti[col];
      if(quanti_c != 0)
      {
        for(int passo_c=N/quanti_c; passo_c <= N/2; passo_c++)
        {             
           if(N%passo_c == 0)
           {
               for(int comincia_da=0; comincia_da <= N/passo_c; comincia_da++)  
                  if(collane[col][comincia_da] < passo_c)
                      risposta += controlla(col, collane[col][comincia_da], passo_c);
           }
        }   
      }
   }

   file=fopen("output.txt", "w");              // OUTPUT
   fprintf(file, "%d", risposta);
   fclose(file);
   
// getchar();
   return 0;
}