Функция неверно заполняет матрицу - C (СИ)

Узнай цену своей работы

Формулировка задачи:

Здравствуйте, в программе функция неверно вводит массив А, заполняет первый столбец числами, остальную часть нулями. Никак не могу найти ошибку, буду благодарен за помощь. И если не трудно, можете часть программы, которая максимальный элемент столбца помещает вверх, записать в виде функции с вызовом. Я плохо разбираюсь в функциях и хочу на примере разобраться, так как мне всю программу нужно раскидать по функциям. Заранее спасибо!!! 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int VVOD_A(int **arr, int M)
{int i,j,N;

   printf("Введённая матрица A\n");
 for ( i = 0; i < N; i++ )
 {
        for ( j = 0; j < M; j++ )
        {
            arr[ i ][ j ] = rand() % 50;
             printf( "\n" );
}}}
 
int main() {
 
 int i, j, max, t,temp,k,min,N,M,index_max;
    setlocale (0,"rus");
    srand( time( NULL ) );
  printf("Введите порядок массива: ");
  scanf("%d", &N);
M=N;
 
int **arr = (int**)malloc(N*M * sizeof(int*));
   for (i = 0; i < N; i++)
    {
              arr[i] = (int*)malloc(N * sizeof(int));
    }
 
    int **brr = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              brr[i] = (int*)malloc(N * sizeof(int));
    }

 /*printf("Введённая матрица A\n");
 for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
            arr[ i ][ j ] = rand() % 50;
            printf( " |%3d| ", arr[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );*/
 
  VVOD_A(&arr,M);
 for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
            printf( " |%3d| ", arr[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );

printf("Максимальный элемент наверх А\n");
 for ( j = 0; j < M; j++ ) {
        max = arr[ 0 ][ j ];
        int index_max = 0;
        for ( i = 1; i < N; i++ )
            if ( arr[ i ][ j ] > max ) {
                max = arr[ i ][ j ];
                index_max = i;}
 t = arr[ 0 ][ j ];
        arr[ 0 ][ j ] = max;
        arr[ index_max ][ j ] = t; }
 
    for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
 printf( " |%3d| ", arr[ i ][ j ] );
        }
    printf( "\n" );
    }
    printf( "\n" );

  printf("Транспонированная матрица А\n");
int **ATR = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              ATR[i] = (int*)malloc(N * sizeof(int));
    }
for(i=0; i<N; ++i){
for(j=i; j<N; ++j)
{ temp=arr[i][j];
ATR[i][j]=arr[j][i];
ATR[j][i]=temp;
}
}
for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
 printf( " |%3d| ", ATR[ i ][ j ] );
        }
    printf( "\n" );
    }
    printf( "\n" );

printf("Введённая матрица B\n");
 for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
            brr[ i ][ j ] = rand() % 50;
            printf( " |%3d| ", brr[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
 
printf("Транспонированная матрица B\n");
int **BTR = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              BTR[i] = (int*)malloc(N * sizeof(int));
    }
for(i=0; i<N; ++i){
for(j=i; j<N; ++j)
{ temp=brr[i][j];
BTR[i][j]=brr[j][i];
BTR[j][i]=temp;
}
}
for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
 printf( " |%3d| ", BTR[ i ][ j ] );
        }
    printf( "\n" );
    }
    printf( "\n" );

printf("AT*B\n");
int **C = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              C[i] = (int*)malloc(N * sizeof(int));
    }
for (i = 0; i < N; i++)
            for (j = 0; j < M; j++)
            {
                C[i][j] = 0;
                for (k = 0; k < M; k++)
                    C[i][j] += ATR[i][k] * brr[k][j];}
 
        for ( i = 0; i < N; i++ )
    {
        for ( j = 0; j < M; j++ ) {
 printf( " |%3d| ", C[i][j] );
        }
    printf( "\n" );
    }
    printf( "\n" );

printf("BT*A\n");
int **X = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              X[i] = (int*)malloc(N * sizeof(int));
    }
for (i = 0; i < N; i++)
            for (j = 0; j < M; j++)
            {
                X[i][j] = 0;
                for (k = 0; k < M; k++)
                    X[i][j] += BTR[i][k] * arr[k][j];}
 
        for ( i = 0; i < N; i++ )
    {
        for ( j = 0; j < M; j++ ) {
 printf( " |%3d| ", X[i][j] );
        }
    printf( "\n" );
    }
    printf( "\n" );

printf("BT*A-AT*B\n");
int **S = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              S[i] = (int*)malloc(N * sizeof(int));
    }
 for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
           S[i][j]=X[i][j] - C[i][j];
 
            printf( " |%3d| ", S[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
 
printf("Введённая матрица 6E\n");
int **E = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              E[i] = (int*)malloc(N * sizeof(int));
    }
 
for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
           if (i==j){E[i][j]=6;}
           else{E[i][j]=0;}
 
            printf( " |%3d| ", E[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
 
printf("A-6E\n");
int **V = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              V[i] = (int*)malloc(N * sizeof(int));
    }
 for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
           V[i][j]=arr[i][j] - E[i][j];
 
            printf( " |%3d| ", V[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
 
    printf("min\n");
    int index_min = 0;
    min = fabs(brr[ 0 ][ j ]);
 
    for (j = 0; j < M; j++)
        {for ( i = 0; i < N; i++ )
            if ( fabs(brr[ i ][ j ]) < min ) {
                min = brr[ i ][ j ];
                }}
 
            printf( " |%3d| ", min );
        printf( "\n" );
 //for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
 
printf("Транспонированная матрица A-6E\n");
int **AETR = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
      AETR[i] = (int*)malloc(N * sizeof(int));
    }
for(i=0; i<N; ++i){
for(j=i; j<N; ++j)
{ temp=V[i][j];
AETR[i][j]=V[j][i];
AETR[j][i]=temp;
}
}
for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
 printf( " |%3d| ", AETR[ i ][ j ] );
        }
    printf( "\n" );
    }
    printf( "\n" );
 
printf("Две скобки -\n");
int **F = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              F[i] = (int*)malloc(N * sizeof(int));
    }
 for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
           F[i][j]=S[i][j] - AETR[i][j];
 
            printf( "   |%3d|   ", F[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
 
if (min==0){printf("Минимальный элемент равен 0, следовательно деление невозможно!\n");}
    else {printf("Ответ\n");
       int **OTV = (int**)malloc(N*M * sizeof(int*));
    for (i = 0; i < N; i++)
    {
              OTV[i] = (int*)malloc(N * sizeof(int));
    }
 for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
           OTV[i][j]=F[i][j] / min;
 
            printf( "   |%3d|   ", OTV[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
 
    }
 
getchar();getchar();
    return 0;
}

Решение задачи: «Функция неверно заполняет матрицу»

textual
Листинг программы 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include<math.h>
int **VVOD(int N, int M);
void free_memory(int **arr,int N);
void VIVOD(int **arr,int N, int M);
void max_up(int **arr,int N, int M);
int **tran(int **arr,int N,int M);
int **mult(int **arr, int **brr,int N,int M);
int **sub(int **arr, int **brr,int N,int M);
int **divis(int **arr,int N,int M, int min);
int main(void)
{ 
 int i, j, max, t,temp,k,min,N,M,index_max;
 int **arr,**brr, **ATR,**BTR,**C,**X,**S,**E,**V,**AETR,**F,**OTV;
    srand( time( NULL ) );
    
  printf("Enter size of matrix: ");
  scanf("%d", &N);
    M=N; 
  
printf("Entered matrix A:\n");
arr=VVOD(N,M);
VIVOD(arr,N,M);
  
printf("Maximum element up A\n");
max_up(arr,N,M);
VIVOD(arr,N,M);
 
printf("transposed matrix A\n");
ATR =tran(arr,N,M);
VIVOD(ATR,N,M);
 
printf("Entered matrix B:\n");  
brr=VVOD(N,M);
VIVOD(brr,N,M);
 
printf("transposed matrix B\n");
BTR =tran(arr,N,M);
VIVOD(BTR,N,M);
  
printf("AT*B\n");
C=mult(ATR,brr,N,M);
VIVOD(C,N,M);
 
printf("BT*A\n");
X=mult(BTR,arr,N,M);
VIVOD(X,N,M);
 
printf("BT*A-AT*B\n");
S=sub(X,C,N,M);
VIVOD(S,N,M);
 
printf("Entered matrix 6E\n");
 E=VVOD(N,M);
for ( i = 0; i < N; i++ ) 
    for ( j = 0; j < M; j++ ) 
           if (i==j)E[i][j]=6;
           else E[i][j]=0;
VIVOD(E,N,M); 
            
printf("A-6E\n");
V=sub(arr,E,N,M);
VIVOD(V,N,M);
 
//здесь не слишком понятно какой минимум искать.
    printf("min\n");
    int index_min = 0;
    min = fabs(brr[ 0 ][ j ]);
 
    for (j = 0; j < M; j++)
        {for ( i = 0; i < N; i++ )
            if ( fabs(brr[ i ][ j ]) < min ) {
                min = brr[ i ][ j ];
                }}
 
            printf( " |%3d| ", min );
        printf( "\n" );
 //for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
//
 
 
printf("transposed matrix A-6E\n");
AETR =tran(V,N,M);
VIVOD(V,N,M);
 
printf("Two semicolons -\n");
F=sub(S,AETR,N,M);
VIVOD(F,N,M);
 
if (min==0){printf("Минимальный элемент равен 0, следовательно деление невозможно!\n");}
    else {printf("Ответ\n");
    OTV=divis(F,N,M,min);
    VIVOD(OTV,N,M);
   }
 
 
free_memory(arr,N); 
free_memory(brr,N);
free_memory(ATR,N);
free_memory(BTR,N);
free_memory(C,N);
free_memory(X,N);
free_memory(S,N);
free_memory(E,N);
free_memory(V,N);
free_memory(AETR,N);
free_memory(F,N);
free_memory(OTV,N);    
    return 0;
}
 
 
int ** VVOD(int N, int M)
{
    int i,j,**arr;
 
arr = (int**)malloc(N * sizeof(int*));
   for (i = 0; i < N; i++)
        arr[i] = (int*)malloc(M * sizeof(int)); 
    
 for ( i = 0; i < N; i++ )
        for ( j = 0; j < M; j++ )
            arr[ i ][ j ] = rand() % 50;
    return arr;
}
void free_memory(int **arr,int N)
{
    int i;
    for(i=0;i<N;i++)
    free(arr[i]);
    free(arr);
}
void VIVOD(int **arr,int N, int M)
{
    
    int i,j;
    for ( i = 0; i < N; i++ ) {
        for ( j = 0; j < M; j++ ) {
            printf( " |%3d| ", arr[ i ][ j ] );}
        printf( "\n" );}
 for ( j = 0; j < M; j++ )
        printf( " ----- " );
    printf( "\n" );
    
}
void max_up(int **arr,int N, int M)
{
    int i,j,max,index_max,t;
 for ( j = 0; j < M; j++ ) {
        max = arr[ 0 ][ j ];
         index_max = 0;
        for ( i = 1; i < N; i++ )
            if ( arr[ i ][ j ] > max ) {
                max = arr[ i ][ j ];
                index_max = i;}
 t = arr[ 0 ][ j ];
        arr[ 0 ][ j ] = max;
        arr[ index_max ][ j ] = t; }    
}
 
int **tran(int **arr,int N,int M)
{
    int i,j,temp;
    int **t;
    t=VVOD(N,M);
    for(i=0; i<N; ++i){
for(j=i; j<M; ++j)
{ temp=arr[i][j];
t[i][j]=arr[j][i];
t[j][i]=temp;
}
}
return t;
}
 
int **mult(int **arr, int **brr,int N,int M)
{
    int **C,i,j,k;
    C=VVOD(N,M);
for (i = 0; i < N; i++)
        for (j = 0; j < M; j++)
            {
                C[i][j] = 0;
                for (k = 0; k < M; k++)
                    C[i][j] += arr[i][k] * brr[k][j];}
 
 
return C;   
}
 
int **sub(int **arr, int **brr,int N,int M)
{
    
    int **S,i,j;
    S=VVOD(N,M);
 for ( i = 0; i < N; i++ ) 
        for ( j = 0; j < M; j++ ) 
           S[i][j]=arr[i][j] - brr[i][j];
 
     return S;       
    
}
 
int **divis(int **arr,int N,int M, int min)
{
    
    int **OTV,i,j;
    OTV=VVOD(N,M);
    
 for ( i = 0; i < N; i++ ) 
        for ( j = 0; j < M; j++ ) 
           OTV[i][j]=arr[i][j] / min;
 
    return OTV;
}

Объяснение кода листинга программы

Этот код представляет собой программу на языке C, которая выполняет различные операции над матрицами. Вначале определяется размер матрицы и считывается из входных данных. Затем создается матрица A и выводится её содержимое. Далее выполняются следующие действия:

  1. Вычисляется максимальное значение в матрице A и индекс этого значения.
  2. Выполняется операция транспонирования матрицы A.
  3. Создается матрица B и выводится её содержимое.
  4. Вычисляется произведение матриц A и B.
  5. Вычисляется произведение матриц B и A.
  6. Вычисляется разность матриц B и A.
  7. Создается матрица 6E, в которой все элементы равны 6.
  8. Вычисляется разность матриц A и матрицы 6E.
  9. Вычисляется минимальное значение в матрице B и проверяется, равно ли оно нулю. Если да, то выводится сообщение о невозможности деления. В противном случае выполняется операция деления матрицы B на минимальное значение и выводится результат.
  10. Все используемые матрицы освобождаются от выделенной для них памяти. Номер 20 не используется в коде.

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

15   голосов , оценка 3.933 из 5
Похожие ответы