zaciatocnik - C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define AND &&
#define rezerva 0.05

int over(float p1[6][7], int a, int k, int n){
      int i;
      i=a;
      p1[i][3]>=1?n++:k++;
                                              }

double vstup(int a, float p1[6][7], float Dmj1r, float Smj1r, float Vmj1r, float Dpal, float Spal, float Vlp, float Vpal)     
{ int i;
  i=a;
 {
         p1[i][0]=Dmj1r; p1[i][1]=Smj1r; p1[i][2]=Vmj1r;
         p1[i][3]=(floor(Dpal/Dmj1r))*(floor(Spal/Smj1r));                  //pk1v
         p1[i][4]=floor((Vlp-(Vpal+rezerva))/Vmj1r);                               //pv 
         p1[i][5]=Vpal+(p1[i][4]*Vmj1r);                                         //vmj2r
         p1[i][6]=p1[i][3]*p1[i][4];                                         //pknapal
 }
}

void perm(float *a, float *b){
     float p;
           p=*a;
          *a=*b;
          *b=p;
                             }
float ppm(float pozd, float priec, float Dpal, float Spal, float Dlp, float Slp, float max, float Nlp){
       float opt;
       pozd=(floor(Dlp/Dpal))*(floor(Slp/Spal));
       priec=(floor(Dlp/Spal))*(floor(Slp/Dpal));
       
       if((priec*max)>Nlp && (pozd*max)>Nlp){
       opt=floor(Nlp/max);
                                            }
       else if((pozd>priec?pozd:priec)*max>Nlp && (pozd>priec?priec:pozd)*max<Nlp){
       opt=(pozd>priec?priec:pozd);
                                                                                  }
       else if(pozd>priec){
               opt=pozd;
                          }
               else if(pozd<priec){
                    opt=priec;
                                  }
                    else if(pozd==priec){
                    opt=priec;
                                        }
       printf("ppm je %.0f", opt);
       }
main(int argc, char *argv[]) {
       int i, j, k, n, m, g, f, q, r, a;
       float Dmj1r, Smj1r, Vmj1r, Hmj1r, Qmj1r, Dpal, Spal, Vpal, Hpal, Dlp, Slp, Vlp, Nlp,
              pv, Vmj2r, Hmj2r, max, pozd, priec, maxf;
       float p1[6][7];       
       float (*dyn_pole)[7];
       //=======================================================================     
       printf("zadaj DLZKU palety v <m>: \n"); scanf("%f",&Dpal);
       printf("zadaj SIRKU palety v <m>: \n"); scanf("%f",&Spal);
       printf("zadaj VYSKU palety v <m>: \n"); scanf("%f",&Vpal);
       printf("zadaj VAHU palety v <m>: \n"); scanf("%f",&Hpal);
       //--------------------------------------------------------
       do{
       printf("zadaj 1. rozmer mj1r v <m>: \n"); scanf("%f",&Dmj1r);
       if(Dmj1r>Dpal)
       printf("Tento rozmer je vacsi nez dlzka palety\n");
         }
         while(Dmj1r>Dpal);
       //-------------------------------------------------------
       do{
       printf("zadaj 2. rozmer mj1r v <m>: \n"); scanf("%f",&Smj1r);
       if(Smj1r>Spal)
       printf("Tento rozmer je vacsi nez sirka palety\n");
         }
         while(Smj1r>Spal);
        //------------------------------------------------------
       printf("zadaj 3. rozmer mj1r v <m>: \n"); scanf("%f",&Vmj1r);
       printf("zadaj HMOTNOST mj1r v <kg>: \n"); scanf("%f",&Hmj1r);
       printf("zadaj POCET mj1r v <ks>: \n"); scanf("%f",&Qmj1r);   
       printf("\nzadaj DLZKU loznej plochy v <m>: \n"); scanf("%f",&Dlp);
       printf("zadaj SIRKU loznej plochy v <m>: \n"); scanf("%f",&Slp);
      printf("zadaj VYSKU loznej plochy v <m>: \n"); scanf("%f",&Vlp);
       printf("zadaj NOSNOST loznej plochy v <kg>: \n"); scanf("%f",&Nlp);
       //=======================================================================
     
        a=n=k=0;
       
       //---------------------------perm 1. az 6. -------------------1
       perm(&Dmj1r, &Smj1r);
       vstup(a, p1, Dmj1r, Smj1r, Vmj1r, Dpal, Spal, Vlp, Vpal);
       over(p1, a, k, n);
       a++;
       //------------------------------------------------------------2
       perm(&Smj1r, &Vmj1r);
       vstup(a, p1, Dmj1r, Smj1r, Vmj1r, Dpal, Spal, Vlp, Vpal);
       over(p1, a, k, n);
       a++;
       //------------------------------------------------------------3
       perm(&Dmj1r, &Smj1r);
       vstup(a, p1, Dmj1r, Smj1r, Vmj1r, Dpal, Spal, Vlp, Vpal);
       over(p1, a, k, n);
       a++;
       //------------------------------------------------------------4
       perm(&Smj1r, &Vmj1r);
       vstup(a, p1, Dmj1r, Smj1r, Vmj1r, Dpal, Spal, Vlp, Vpal);
       over(p1, a, k, n);
       a++;
       //------------------------------------------------------------5
       perm(&Dmj1r, &Smj1r);
       vstup(a, p1, Dmj1r, Smj1r, Vmj1r, Dpal, Spal, Vlp, Vpal);
       over(p1, a, k, n);
       a++;
       //------------------------------------------------------------6
       perm(&Smj1r, &Vmj1r);
       vstup(a, p1, Dmj1r, Smj1r, Vmj1r, Dpal, Spal, Vlp, Vpal);
       over(p1, a, k, n);
       a++;
       //------------------------------------------------------------
       printf("\n n a k - %i - %i\n", n, k);           //n- pocet pouzitelnych ulozeni, k- pocet nepouzitelnych ulzeni na paletu
     

      printf("D     S     V      pk1v    pv   vmj2r   pknapal     \n");       
       for(i=0;i<6;i++){                           
           for(j=0;j<7;j++)                         
                                                               /*      STAT. MATICA       */
                        printf(" %.3f",p1[i][j]);   
                        printf(" \n");             
                       
                       }
     
     
 
   
      maxf=p1[0][6]; f=0;
      for(i=0,j=6; i<6; i++){
                           if(maxf<p1[i][6]){
                           printf(" %i\n",i);                      //i-vytlaci indexi vyhovujucich riadkov
                           f++;                                    //f-pocet vyhovujucich riadkov kde je rovnaky max v 6 slpci
                           g=i;             }                      //g-index posledneho najdeneho maxu v stlpci
                            }                                 
     
      printf("\n %i\n",f);
      for(j=0; j<7; j++)
      printf(" %.3f",p1[g][j]);          //tlaci len jeden riadok(v poradi posledny ktory najde v predch. poli), problem je ze ich moze byt viac             
 
      dyn_pole=(float(*)[7])malloc(f*7*sizeof(float)); /*******************************/
                                                        /*ODTIAL BY SA MI ZISLO HELPNUT*/
      for(q=0; q<f; q++){                              /*****???????????????????*******/
      for(r=0; r<7; r++){
         
                        }
                       }
     
system("pause");
}



                                    


                               

int over(float p1[6][7], int a, int k, int n){
      int i;
      i=a;
      p1[i][3]>=1?n++:k++;
                                              }

int over(float p1[6][7], int a, int *k, int *n){
      int i;
      i=a;
      p1[i][3]>=1 ? (*n)++: (*k)++;
                                              }

        printf(" %.3f",p1[g][j]);          //tlaci len jeden riadok(v poradi posledny ktory najde v predch. poli), problem je ze ich moze byt viac

if(maxf<p1[i][6])

double press(float **p){
      int i, j;
           
       for(i=0;i<6;i++){                           
           for(j=0;j<7;j++)                         
                                                   
                        printf(" %.3f",&p[i][j]);   
                        printf(" \n");             
                       
                       }
                      }

 press(p1);

for ( q = 0; q < f; q++ )
    for ( r = 0; r < 7; r++ )
        dyn_pole[q][r] = p1[ indexy[q] ][r];

double press( float p[][7] )

printf( " %.3f\n", p[i][j] );

 pocet_vyskytu_max=0; 
       for ( i = 0; i < 6; i++ ){
           if(max_in(pole_a)==pole_a[i])          /* fcia max_in(pole_a) vracia maximum 6-prvkoveho  pola_a */
           pocet_vyskytu_max++;
                                        }
         
           pole_indexov=(int*)malloc(pocet_vyskytu_max*sizeof(int));
           for ( i = 0; i < 6; i++ ){
               if(max_in(pole_a)==pole_a[i]){
                 for( j = 0; j <pocet_vyskytu_max ; j++ )
                     pole_indexov[j]=i;     }               
                                    }
           
           
           for( j = 0; j <pocet_vyskytu_max ; j++ )   
            printf("\n %i \n", pole_indexov[j]);
       free(pole?indexov);

if(max_in(pole_a)==pole_a[i]){
                 for( j = 0; j <pocet_vyskytu_max ; j++ )
                     pole_indexov[j]=i;     }

int pi_index = 0;
/* vsetok predchadzajuci kod az po hore uvedeny chybny blok */
for ( i = 0; i < 6; i++ )
{
    if ( max_in( pole_a ) == pole_a[i] )
        pole_indexov[ pi_index++ ] = i;
}

int tmp_max = max_in(pole_a);
int pole_indexov[6];
int pocet_vyskytu_max=0;

for (i=0; i<6; i++) {
  if(tmp_max==pole_a[i]) {
    pole_indexov[pocet_vyskytu_max]=i;
    printf("\n %d \n", i);
    pocet_vyskytu_max++;
  }
}

  t = pocet_vyskytu_max( pole_a ) ; b = 0 ;
           dyn_pole = ( float ( * ) [ ] ) malloc ( t * 7 * sizeof ( float ) ) ;                                 
           for ( i = 0; i < t; i++ ){                                             /*fica max_in() vracia int max pola*/
                                                                                         /*fcia pocet_vyskytu_max() vracia int
               for ( j = 0; j < 7; j++ )                                         ale obsahuje fciu max_in()*/
               if ( max_in ( pole_a ) == pole_a[ i ]){
                   dyn_pole[ b ][ j ] = pole_b[ i ][ j ]; b++ ;     }               
                                    }
         
          for ( i = 0; i < t; i++ ){
               for ( j = 0; j < 7; j++ )
               printf("\n %.3f \n", dyn_pole[ i ][ j ]);}
           
               free (dyn_pole );

int pocet_vyskytu_max(float *p){                                                       
    int i, f=0;
    for(i=0; i<6; i++){
        if(max_in(p)==p[i])
        f++;          }
        return f;      }

int max_in(float *p){                                                           
      int i, j;
      float m=p[0];
      for ( i = 0; i < 6; i++ ){
          if(m<p[i])
             m=p[i];
                             
                               }
      return m;                 
                   } 

for ( j = 0; j < 7; j++ )
    if ( max_in ( pole_a ) == pole_a[ i ]){
        dyn_pole[ b ][ j ] = pole_b[ i ][ j ]; b++ ;     }

if ( max_in ( pole_a ) == pole_a[ i ])
{
    for ( j = 0; j < 7; j++ )
        dyn_pole[ b ][ j ] = pole_b[ i ][ j ];
    b++;
}