C Programa com matriz 5x5 em C

IgorS10 · 15 de novembro de 2022

Deve ter múltiplos do 5 na diagonal principal, múltiplos do 11 acima da diagonal principal e múltiplos do 13 abaixo da diagonal principal.

Deve verificar primeiro se o número é múltiplo do 5, se não se é múltiplo do 11, se não se é múltiplo do 13, se não for também deverá aparecer a mensagem "número inválido".

Quando a matriz com a diagonal principal com os múltiplos do 5 tiver completa, deverá aparecer a mensagem "diagonal principal preenchida".
Quando a matriz acima da diagonal principal com os múltiplos do 11 tiver completa, deverá aparecer a mensagem "não existe espaço acima da diagonal principal".
Quando a matriz abaixo da diagonal principal com os múltiplos do 13 tiver completa, deverá aparecer a mensagem "não existe espaço abaixo da diagonal principal".
Quando a matriz tiver completamente preenchida, deverá mostrar todos os elementos da matriz junto com suas posições.

Shaman93 · 15 de novembro de 2022

Sim, mas qual sua dúvida?

IgorS10 · 15 de novembro de 2022

@Shaman93 Em inserir os múltiplos do 5, 11 e 13 nas suas posições na matriz.

DiF · 15 de novembro de 2022

@IgorS10

Caro usuário,

Seja bem-vindo ao Clube do Hardware.

No intuito de servir como fonte de pesquisa no caso de instituições de ensino, informamos que incorrer no resolvimento por completo de questões relacionadas a disciplinas escolares de cursos técnicos e faculdades podem ser revistas e removidas pela Equipe de Moderação do Clube do Hardware.

Para sanar dúvidas sobre esse tipo de problema, por gentileza, publique o passo a passo do desenvolvimento da questão, projeto, monografia ou conteúdo em dúvida para que possamos analisar se a resposta está correta ou não, ou para que possa ser auxiliado com a dúvida no desenvolvimento do exercício.

Infelizmente, não há como resolver os trabalhos pelos usuários. O objetivo do Clube do Hardware é auxiliar seus usuários a encontrar soluções para que possam sanar suas dúvidas, e não de trazer soluções prontas para seus usuários. Além disso, copiar e colar respostas que não são de autoria própria do qualquer usuário é considerado plágio, o que é ilegal.

Esperamos que compreenda.

Atenciosamente,

Equipe Clube do Hardware

devair1010 · 15 de novembro de 2022

@IgorS10 você insere números em um vetor / matriz usando o sinal de igualdade "=" , e os números você pode pegar do usuário através do teclado , usando scanf , ou gerar aleatório com a função rand() , e para saber essas opções citadas no enunciado você com certeza irá precisar usar o comando if para fazer as comparações que decidem se aquelas opções foram satisfeitas . faça seu código e poste aqui e ajudaremos se precisar .

arfneto · 15 de novembro de 2022

3 horas atrás, IgorS10 disse:

Em inserir os múltiplos do 5, 11 e 13 nas suas posições na matriz.

Isso não é uma dúvida de C. Trata-se do ensino fundamental:

Se i é inteiro

5*i é múltiplo de 5.
11*i é múltiplo de 11
13*i é multiplo de 13

4 horas atrás, IgorS10 disse:

acima da diagonal principal

então tem um termo na matriz M(A,B)

se A == B então o termo está na diagonal principal. Se A < B então o termo está acima da diagonal principal.
se não estiver acima da diagonal principal nem na diagonal principal então...
está abaixo da diagonal principal.

IgorS10 · 16 de novembro de 2022

@devair1010 Ainda não deu

@arfneto Não sei se falta muita coisa

arfneto · 16 de novembro de 2022

por favor não poste imagens.

Como não postou um enunciado formal nem como está o código agora não vejo como ajudar.

Escreveu uma função para mostrar a matriz?
Escreveu uma função para preencher a matriz?
Já sabe os critérios. São 3 regiões e 3 critérios ao que parece.
Eu te mostrei os conceitos acima. A parte de C é preencher a matriz e mostrar.

O que falta então?

devair1010 · 16 de novembro de 2022

@IgorS10 você está inserindo os números Que com certeza são os múltiplos na matriz , e assim não tem necessidade de testar para saber se são múltiplos desses números ou não , mas mesmo assim se Quiser testa los ou se inserir outros números e testar também , pode usar o operador MOD que na linguagem C é esse símbolo "%" , e pode fazer com apenas um loop , que seria assim :

/// Deve ter moltiplos do 5 na diagonal principal, moltiplos do 11 acima da
/// diagonal principal e moltiplos do 13 abaixo da diagonal principal.
/// Deve verificar primeiro se o nomero ie moltiplo do 5, se non se ie moltiplo
/// do 11, se non se ie moltiplo do 13, se non for tambim deveria aparecer a
/// mensagem "nomero invelido".
/// Quando a matriz com a diagonal principal com os moltiplos do 5 tiver
/// completa, deveria aparecer a mensagem "diagonal principal preenchida".
/// Quando a matriz acima da diagonal principal com os moltiplos do 11
/// tiver completa, deveria aparecer a mensagem "non existe espaCio acima
/// da diagonal principal".
/// Quando a matriz abaixo da diagonal principal com os moltiplos do
/// 13 tiver completa, deveria aparecer a mensagem "non existe espaCio
/// abaixo da diagonal principal".
/// Quando a matriz tiver completamente preenchida, deveria mostrar todos
/// os elementos da matriz junto com suas posiCiones.
#include   <stdio.h>
#include   <stdlib.h>
int main()
{
  int i      = 5;
  int j      = 5;
  int v_i    = i;
  int num    = 0;
  int diag_p = 0;
  char ax[]  = {"    "};
  int acima_diag_p  = 0;
  int abaixo_diag_p = 0;
  /// int m[i][j];
  printf("\n\tQuer EscoLher o TAM da Matriz Quadrada S/N ");
  fgets(ax , 4 , stdin);
  if(ax[0] != 's' && ax[0] != 'S') /// operador AND
  {
    printf("\n entonces a Matriz seraar de 5x5 mesmo . . . !\n\n"); 
  }                                /// em outro idioma p enganar o corretor ortografico
  else
  {
    printf  (" Quantas Linhas oU coLunas ? " );
    fgets   ( ax , 4 , stdin                 );
    v_i = atoi( ax                           );
    i   = v_i                                 ;
    j   = v_i                                 ;
  }
  printf("\n");
  int** m = (int**) malloc ( i * sizeof(int) ); /// reserva espaCo para as Linhas da Matriz
  for(  i = 0; i<v_i; i++                     )
  {
    m[i] = (int*) malloc ( j * sizeof(int)   ); /// reserva espaCio para as Colunas da Matriz
    for(    j=0; j<v_i; j++                   )
    {
      m[i][j] = 11 * (i + 1);       /// insere com certeza mUltiplos de 11  
      if(i == j)                    /// posiCiones com moltiplos de 5
      {
        m[i][j] =  5 * (i + 1);     /// insere com certeza moltiplos de 5  
        if(m[i][j] % 5 == 0)        /// eh divisavel por cinco e non sobra resto 
                                    /// entonces eh moltiplo de cinco
                                    /// primeiro verifica todas as posiciones da matriz
          diag_p++;                 /// conta qtd na diag_pr
      }
      else
      {
        if( i < j )                 /// posiCiones com moltiplos de 11
        {
          if( m[i][j] % 11 == 0 )   /// e non sobra resto
          {
            acima_diag_p++;         /// conta qtd acima_diag_pr
          }
        }
        else
        {
          if( i > j )               /// posiCiones com moLtiplos de 13
          {
            m[i][j] = 13 * (i + 1); /// insere com certeza moltiplos de 13
            if( m[i][j] % 13 == 0 ) /// e non sobra resto
            {
              abaixo_diag_p++;      /// conta qtd abaixo_diag_pr
            }
            else
              printf(" nomero invelido . . . . !\n");
          }                         /// em outro idioma p enganar o corretor ortografico
        }
      }
      printf("%4d",m[i][j]);
    }
    printf("\n");
  }
  printf("\n Aqui apenas para obServar o valor das variables .\n\n"      );
  printf(" QTD dE moltiplos de 13 abaiXo_d_p -= %3d  \n" , abaixo_diag_p );
  printf(" QTD dE moltiplos de 11  aCimA_d_p -= %3d  \n" ,  acima_diag_p );
  printf(" QTD dE oUltiplos de  5  na    d_p -= %3d\n\n" ,        diag_p );
  printf(" Mostrar o Resultado final .             \n\n"                 );
  if( diag_p == v_i )
    printf(" DiagonaL PrinciPal PreenChida . . . !\n");
  if( acima_diag_p == ( v_i * v_i - v_i ) / 2 )
    printf(" non existe espaCio acima  da diagonal principal . . . !\n");
  if( abaixo_diag_p == ( v_i * v_i - v_i ) / 2 )
    printf(" non existe espaCio abaixo da diagonal principal . . . !\n");
  return 0;                   /// em outro idioma p enganar o corretor ortografico
}

arfneto · 16 de novembro de 2022

41 minutos atrás, devair1010 disse:

você está inserindo os números Que com certeza são os múltiplos na matriz , e assim não tem necessidade de testar para saber se são múltiplos desses números ou não , mas mesmo assim se Quiser testa los

Isto não combina com isso

16 horas atrás, IgorS10 disse:

Deve verificar primeiro se o número é múltiplo do 5, se não se é múltiplo do 11, se não se é múltiplo do 13, se não for também deverá aparecer a mensagem "número inválido".

E esse é o enunciado. Então precisa validar o número antes de tudo. A ordem de validação está bem clara aí. E o comportamento do programa também:

16 horas atrás, IgorS10 disse:

Quando a matriz com a diagonal principal com os múltiplos do 5 tiver completa, deverá aparecer a mensagem "diagonal principal preenchida".

Quando a matriz acima da diagonal principal com os múltiplos do 11 tiver completa, deverá aparecer a mensagem "não existe espaço acima da diagonal principal".

Quando a matriz abaixo da diagonal principal com os múltiplos do 13 tiver completa, deverá aparecer a mensagem "não existe espaço abaixo da diagonal principal".

Quando a matriz tiver completamente preenchida, deverá mostrar todos os elementos da matriz junto com suas posições.

Pode até ficar perguntando os números mas quer mesmo fazer isso? NUNCA escreva um programa interativo. Só vai perder tempo. E não pergunte o que não é claramente devido. Ao procurar problemas você sempre encontra.

O roteiro está bem determinado no enunciado. O que falta fazer? Escreva a função que mostra a matriz. ANTES de tudo. Sem isso não vai saber se está certo. E precisa saber a ordem da matriz. O simples? Na linha de comando, claro. Não seria algo novo. Se seu programa se chama x.exe pode usar

	x 3
	x 7
	x 9

e ter a matriz preenchida de ordem 3, 7 ou 9. Não seria nada novo. Por isso o protótipo de main é

	int main(int argc, char** argv)

arfneto · 16 de novembro de 2022

16 horas atrás, devair1010 disse:

os números você pode pegar do usuário através do teclado , usando scanf ,

Não, não faça isso. Nunca escreva um programa interativo.

Pense bem: para uma matriz 4x4 vai precisar de 16 valores. Para CADA vez que for testar isso. E tem que controlar os múltiplos de 5 de 11 e 13. Um inferno. Ninguém quer isso.

E se fosse 7x7?

16 horas atrás, devair1010 disse:

ou gerar aleatório com a função rand()

Aí sim. Ou podem ser constantes alternadas, tipo o óbvio 5, 11, 13, 22 por exemplo. Assim preenche todos os casos e pode testar tudo sem stress.

int main()
{
  int i      = 5;
  int j      = 5;
  int v_i    = i;
  int num    = 0;
  int diag_p = 0;
  char ax[]  = {"    "};
  int acima_diag_p  = 0;
  int abaixo_diag_p = 0;
  /// int m[i][j];
  printf("\n\tQuer EscoLher o TAM da Matriz Quadrada S/N ");
  fgets(ax , 4 , stdin);
  if(ax[0] != 's' && ax[0] != 'S') /// operador AND
  {
    printf("\n entonces a Matriz seraar de 5x5 mesmo . . . !\n\n"); 
  }                                /// em outro idioma p enganar o corretor ortografico
  else
  {
    printf  (" Quantas Linhas oU coLunas ? " );
    fgets   ( ax , 4 , stdin                 );
    v_i = atoi( ax                           );
    i   = v_i                                 ;
    j   = v_i                                 ;
  }
  printf("\n");
  int** m = (int**) malloc ( i * sizeof(int) ); /// reserva espaCo para as Linhas da Matriz
  for(  i = 0; i<v_i; i++                     )
  {
    m[i] = (int*) malloc ( j * sizeof(int)   ); /// reserva espaCio para as Colunas da Matriz
    for(    j=0; j<v_i; j++                   )
    {
      m[i][j] = 11 * (i + 1);       /// insere com certeza mUltiplos de 11  
      if(i == j)                    /// posiCiones com moltiplos de 5
      {
        m[i][j] =  5 * (i + 1);     /// insere com certeza moltiplos de 5  
        if(m[i][j] % 5 == 0)        /// eh divisavel por cinco e non sobra resto 
                                    /// entonces eh moltiplo de cinco
                                    /// primeiro verifica todas as posiciones da matriz
          diag_p++;                 /// conta qtd na diag_pr
      }
      else
      {
        if( i < j )                 /// posiCiones com moltiplos de 11
        {
          if( m[i][j] % 11 == 0 )   /// e non sobra resto
          {
            acima_diag_p++;         /// conta qtd acima_diag_pr
          }
        }
        else
        {
          if( i > j )               /// posiCiones com moLtiplos de 13
          {
            m[i][j] = 13 * (i + 1); /// insere com certeza moltiplos de 13
            if( m[i][j] % 13 == 0 ) /// e non sobra resto
            {
              abaixo_diag_p++;      /// conta qtd abaixo_diag_pr
            }
            else
              printf(" nomero invelido . . . . !\n");
          }                         /// em outro idioma p enganar o corretor ortografico
        }
      }
      printf("%4d",m[i][j]);
    }
    printf("\n");
  }

@devair1010 sobre esse trecho então tenta criar `m` e 'm' é a matriz quadrada m(i,j) e você acabou de ler v_i que é i e j claro.

Essa não é uma maneira segura de escrever porque ao olhar para m nada se sabe sobre a ordem. Falta o valor v_i. Por essa razão o simples e seguro é tratar os dois sempre juntos. Encapsulamento é a palavra chique, mas o fato é que precisa sempre dos dois e o melhor é juntar numa estrutura. Veja main por exemplo: sempre são dois argumentos:

	int main(int argc, char** argv);

e o motivo é esse.

E o código está errado. E não tem os correspondentes free() ao final.

Se a matriz é 'm' e tem i linhas então cada linha de 'm' é um ponteiro para um vetor de int onde tem 'j' colunas.

    int** m = (int**)malloc(
        i * sizeof(int));  /// reserva espaCo para as Linhas
                           /// da Matriz

Está errado: são ponteiros para ínt e não int.

E não deve misturar a criação da matriz com o preenchimento. Só vai complicar sua vida. Escreva funções que fazem UMA e UMA SÓ coisa.

arfneto · 17 de novembro de 2022

Pode parecer vago isso de escrever em torno dos dados . E esse lance de NUNCA escrever um programa interativo, outra coisa que eu escrevo sempre aqui.

Então vou deixar um exemplo de como seria fazer exatamente isso com esse programa. Espero que sirva para ilustrar uma maneira de escrever esse tipo de programa, ou qualquer programa, a partir dos dados.

O primeiro passo será usar uma matriz de `int` constante 4x4 e uma função `mostra()` que faz o óbvio. E tratar a definição da ordem da matriz, que vem na linha de comando e tem o _default_ `5`. As mensagens já serão copiadas direto do enunciado e tudo o mais que der para aproveitar

A matriz

    int  t[] = {1, 2,  3,  4,  5,  6,  7,  8,
                9, 10, 11, 12, 13, 14, 15, 16};
    int* m[] = {t, t + 4, t + 8, t + 12};

Assim dá pra testar a matriz 4x4, e tambem 2x2 ou 3x3. E sem ficar digitando números para cada teste.

### Do enunciado ###

Citação

Deve ter múltiplos do 5 na diagonal principal, múltiplos do 11 acima da diagonal principal e múltiplos do 13 abaixo da diagonal principal.

Deve verificar primeiro se o número é múltiplo do 5, se não se é múltiplo do 11, se não se é múltiplo do 13, se não for também deverá aparecer a mensagem "número inválido".

Quando a matriz com a diagonal principal com os múltiplos do 5 tiver completa, deverá aparecer a mensagem "diagonal principal preenchida".

Quando a matriz acima da diagonal principal com os múltiplos do 11 tiver completa, deverá aparecer a mensagem "não existe espaço acima da diagonal principal".

Quando a matriz abaixo da diagonal principal com os múltiplos do 13 tiver completa, deverá aparecer a mensagem "não existe espaço abaixo da diagonal principal".
Quando a matriz tiver completamente preenchida, deverá mostrar todos os elementos da matriz junto com suas posições.

Então vem uma matriz `NxN` que vai ser preenchida com 3 tipos de números:

na diagonal múltiplos de `5`
acima da diagonal múltiplos de `11`
abaixo da diagonal múltiplos de `13`
números que não atendam esses critérios devem ser mostrados como "inválidos"
ao final claro que a matriz deve ser mostrada

### Algumas definições ###

Para começar a testar logo se pode usar apenas números como 5, 11, 13 e outro como 42 e preencher a matriz, mas como é trivial fazer isso então:
- definição 1: usar números aleatórios para preencher a matriz, números positivos entre 1 e algum limite.
- definição 2: representar a matriz como um vetor `int**` e uma certa ordem `N`.
- definição 3: limitar a ordem entre 2 e 10 linhas/colunas. Tem que ter um limite razoável afinal.
- definição 4: o programa vai ser `x.exe` e para rodar basta entrar com o valor de `N` na linha de comando. O padrão será `5` para poder rodar sem ter que digitar algo sempre

Exemplos:

    x 345 // vai assumir 5x5 porque 345 está fora do limite
    x 2 // matriz 2 x 2, a menor
    x 10 // matrix 10 x 10, a maior aceita
    x // assume 5x5, o padrão
    x Clube do Hardware // vai assumir 5

### Um primeiro programa, completo, para testar em 10 minutos ###

Copiando o que já tem no enunciado e apenas aproveitando para validar as coisas

#define INVALIDO_ 0
#define PRINCIPAL_ 1
#define ABAIXO_ 3
#define ACIMA_ 2

#include <stdio.h>
#include <stdlib.h>

int mostra(unsigned, int**, const char*);

int main(int argc, char** argv)
{
    int  t[] = {1, 2,  3,  4,  5,  6,  7,  8,
                9, 10, 11, 12, 13, 14, 15, 16};
    int* m[] = {t, t + 4, t + 8, t + 12};

    const char* msg[] = {
        "numero invalido", "diagonal principal preenchida",
        "não existe espaco acima da diagonal principal",
        "não existe espaco abaixo da diagonal principal"};
    const int  limite  = 100 * 1000;  // 5 digitos no maximo
    const long semente = 20221115;    // para o gerador

    unsigned ordem = 5;  // matriz 5x5 padrão
    unsigned val   = 0;
    if (argc > 1)
    {
        val = atoi(argv[1]);
        if ((val > 1) && (val < 11)) ordem = val;
    };
    printf("main() ordem = %lu\n", ordem);
    mostra(3, (int**)m, "mostra() para ordem 3\n");
    mostra(2, (int**)m, "mostra() para ordem 2\n");
    mostra(4, (int**)m, "mostra() para ordem 4\n");
    return 0;
}

int mostra(unsigned ordem, int** mtr, const char* msg)
{
    if (msg != NULL) printf("%s", msg);
    if (mtr == NULL) return -1;
    printf("Usando matriz [%lux%lu]\n", ordem, ordem);

    for (unsigned i = 0; i < ordem; i += 1)
    {
        for (unsigned j = 0; j < ordem; j += 1)
        {
            printf("%8d ", mtr[i][j]);
        }
        printf("\n");  // fim da linha
    }
    printf("\n");  // fim da matriz
    return 0;
}

Aqui tem as mensagens possíveis para os números, copiadas direto do enunciado, e uma matriz 4x4 para testar. A função `mostra()` aceita um título pra facilitar os testes e os óbvios dados: a ordem da matriz e um ponteiro para a matriz.
Assim se pode mostrar a matriz com um título e usando só uma linha de comando.
Se o usuário digitar algo entre 2 e 10 essa será a ordem da matriz e em caso contrário vai ser `5x5` como esperado.

E a matriz já pode ser testada com alguns valores:

PS C:> .\x clube do hardware
main() ordem = 5
mostra() para ordem 3
Usando matriz [3x3]
       1        2        3
       5        6        7
       9       10       11

mostra() para ordem 2
Usando matriz [2x2]
       1        2
       5        6

mostra() para ordem 4
Usando matriz [4x4]
       1        2        3        4
       5        6        7        8
       9       10       11       12
      13       14       15       16

em `main` tem só

    unsigned ordem = 5;  // matriz 5x5 padrão
    if (argc > 1)
    {
        val = atoi(argv[1]);
        if ((val > 1) && (val < 11)) ordem = val;
    };
    printf("main() ordem = %lu\n", ordem);
    mostra(3, (int**)m, "mostra() para ordem 3\n");
    mostra(2, (int**)m, "mostra() para ordem 2\n");
    mostra(4, (int**)m, "mostra() para ordem 4\n");

`main` apenas trata o eventual argumento que veio e depois chama `mostra()` com 3 valores possíveis para a ordem da matriz.

E já testamos algo. Em 10 minutos. E funcionou.

IgorS10 · 18 de novembro de 2022

@arfneto O programa já ta quase pronto, só ta pegando múltiplos do 5,11 e 13 como é solicitado na questão, só falta arrumar esses números nas suas devidas posições, o múltiplo do 5 na diagonal principal, o do 11 acima da diagonal principal e o 13 abaixo da diagonal principal.

arfneto · 18 de novembro de 2022

Seguindo o roteiro a partir do tópico anterior...

### E agora? ###

A matriz foi declarada como `int**` para poder usar a notação comum em C, `m[i][j]` e já deu pra ver que a representação da matriz não serve: é preciso saber a ordem da matriz para saber pra que o ponteiro aponta e o ponteiro sem a ordem não serve para nada. A única função que temos já tem dois argumentos para acessar a matriz mas um não existe sem o outro.

Então eles devem ser um só:

typedef struct
{
    unsigned ord; // linhas/colunas da matriz
    int**    M; // a matriz
}   Matriz;

Assim faz sentido e todo o programa pode tratar todo tipo de `Matriz`. Para isso se escreve um programa afinal: para o genérico. E ao falar em `Matriz` tem todo o necessário: o endereço e a ordem.

### Como criar uma `Matriz`? ###

Apenas precisamos da ordem. Então

    Matriz* cria(unsigned ordem);

seria uma função bem conveniente: chama a função e recebe o endereço de uma `Matriz` novinha e preenchida.

    Matriz uma = cria(8);

retornaria uma `Matriz` 8x8. E claro que essas coisas são escritas aos pares se não se quer perder tempo com isso: se tem `cria()` ao mesmo tempo se escreve `apaga()`. E `mostra()` já existe do outro programa.

E já se pode escrever

    ordem = 10;
    Matriz* tst = cria(ordem);
    mostra(tst, "Testando a matriz: ");
    tst = apaga(tst);

E ter a matriz criada, mostrada e apagada.

E já que se vai criar a matriz vamos criar com valores numerados de 1 até o limite e assim ao chamar `mostra()` já se sabe o que esperar.

### `criar()`: um protótipo ###

Matriz* cria(unsigned ordem)
{   // ordem entre 2 e 10 (inclusive)
    // se fora dos limites assume 5
    if ((ordem < 2)||(ordem > 10) ) ordem = 5;
    // cria uma Matriz
    Matriz* mtr = (Matriz*)malloc(sizeof(Matriz));
    mtr->ord    = ordem; // claro
    // cria as linhas
    mtr->M      = (int**)malloc(ordem*sizeof(int*));
    int val     = 0;
    for (unsigned l = 0; l < ordem; l++)
    {   // cria as colunas
        mtr->M[l] = (int*)malloc(ordem * sizeof(int));
        // pra testar numera os elementos
        for (unsigned c = 0; c < ordem; c += 1)
            mtr->M[l][c] = ++val;
    }
    return mtr;  // retorna Matriz ok
}

Algo simples assim cria uma `Matriz` e retorna o endereço. `C` foi criada para esse tipo de coisa. Cada linha é um vetor. `C` não tem matrizes como `FORTRAN`: tem só vetores. Cada linha tem `N` vetores que apontam para `N` inteiros. E eles são numerados a partir de `1`.

### `apagar()`: um protótipo ###

Matriz* apaga(Matriz* mtr)
{   // apaga a tal matriz
    if ( mtr == NULL ) return NULL;
    printf("Apaga matriz [%lux%lu]\n", mtr->ord, mtr->ord);
    // apaga as colunas
    for (unsigned l = 0; l < mtr->ord; l += 1) free(mtr->M[l]);
    // apaga as linhas
    free(mtr->M);
    // apaga a matriz
    free(mtr);
    return NULL; // retorna NULL
}

O simples: apaga na ordem inversa em que foi criado. Retorna `NULL` para poder invalidar o ponteiro na mesma hora.

### `mostra()` ###

`mostra()` tem que ser alterada para o novo padrão e é trivial: ao invés de

	int mostra(unsigned ordem, int** mtr, const char* msg)

fica o simples

	int mostra(Matriz* mtr, const char* msg)

O endereço de uma `Matriz` e o titulo. Nada mais.

### Versão 2: um programa que cria, mostra e destrói `Matriz` ###

#define INVALIDO_ 0
#define PRINCIPAL_ 1
#define ABAIXO_ 3
#define ACIMA_ 2

#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    unsigned ord; // linhas/colunas da matriz
    int**    M; // a matriz
}   Matriz;

Matriz* apaga(Matriz*);
Matriz* cria(unsigned);
int     mostra(Matriz*, const char*);

int main(int argc, char** argv)
{
    const char* msg[] = {
        "numero invalido",
        "diagonal principal preenchida",
        "não existe espaco acima da diagonal principal",
        "não existe espaco abaixo da diagonal principal"
    };
    const int  limite  = 100 * 1000;  // 5 digitos no maximo
    const long semente = 20221115;    // para o gerador

    unsigned ordem = 5;  // matriz 5x5 padrão
    unsigned val   = 0;
    if (argc > 1)
    {
        val = atoi(argv[1]);
        if ((val > 1) && (val < 11)) ordem = val;
    };
    printf("Usando matriz [%lux%lu]\n", ordem, ordem);
    Matriz* tst = cria(ordem);
    mostra(tst, "Testando a matriz: ");
    tst = apaga(tst);
}

Matriz* apaga(Matriz* mtr)
{   // apaga a tal matriz
    if ( mtr == NULL ) return NULL;
    printf("Apaga matriz [%lux%lu]\n", mtr->ord, mtr->ord);
    // apaga as colunas
    for (unsigned l = 0; l < mtr->ord; l += 1) free(mtr->M[l]);
    // apaga as linhas
    free(mtr->M);
    // apaga a matriz
    free(mtr);
    return NULL; // retorna NULL
}

Matriz* cria(unsigned ordem)
{   // ordem entre 2 e 10 (inclusive)
    // se fora dos limites assume 5
    if ((ordem < 2)||(ordem > 10) ) ordem = 5;
    // cria uma Matriz
    Matriz* mtr = (Matriz*)malloc(sizeof(Matriz));
    mtr->ord    = ordem; // claro
    // cria as linhas
    mtr->M      = (int**)malloc(ordem*sizeof(int*));
    int val     = 0;
    for (unsigned l = 0; l < ordem; l++)
    {   // cria as colunas
        mtr->M[l] = (int*)malloc(ordem * sizeof(int));
        // pra testar numera os elementos
        for (unsigned c = 0; c < ordem; c += 1)
            mtr->M[l][c] = ++val;
    }
    return mtr;  // retorna Matriz ok
}

int mostra(Matriz* mtr, const char* msg)
{
    if (mtr == NULL) return -1;
    if (msg != NULL) printf("%s", msg);
    printf("Usando matriz [%lux%lu]\n", mtr->ord, mtr->ord);

    for (unsigned i = 0; i < mtr->ord; i += 1)
    {
        for (unsigned j = 0; j < mtr->ord; j += 1)
        {
            printf("%8d ", mtr->M[i][j]);
        }
        printf("\n"); // fim da linha
    }
    printf("\n");  // fim da matriz
    return 0;
}

### Saída do segundo programa ###

PS > .\x
Usando matriz [5x5]
Testando a matriz: Usando matriz [5x5]
       1        2        3        4        5
       6        7        8        9       10
      11       12       13       14       15
      16       17       18       19       20
      21       22       23       24       25

Apaga matriz [5x5]

PS > .\x 2
Usando matriz [2x2]
Testando a matriz: Usando matriz [2x2]
       1        2
       3        4

Apaga matriz [2x2]

Claro que isso vai criar e apagar matrizes em qualquer outro programa e basta copiar essas funções para o próximo exercício. Esse é o ponto de escrever em torno dos dados e usar apenas os argumentos recebidos e NUNCA depender de dados externos, muito menos globais.

@IgorS10 Basta um loop para fazer isso. Tem uma pegadinha que é não saber a ordem em que as 3 regiões vão ser preenchidas então um número como 715 por exemplo pode aparecer nas 3 posições por ser múltiplo de 5 11 e 13

IgorS10 · 18 de novembro de 2022

@arfneto @arfneto Um loop ? Sério ?

arfneto · 18 de novembro de 2022

@IgorS10 Rodou os dois programas que eu mostrei? Entendeu a ideia?

tem a abstração da matriz
tem como mostrar a matriz, qualquer tamanho
tem como apagar a matriz
tem como criar a matriz

Fala um loop: pegar um número, ver se é válido e colocar no lugar certo, até encher a matriz.

10 horas atrás, arfneto disse:

em uma pegadinha que é não saber a ordem em que as 3 regiões vão ser preenchidas então um número como 715 por exemplo pode aparecer nas 3 posições por ser múltiplo de 5 11 e 13

E tem esse lance

arfneto · 18 de novembro de 2022

Esse era o programa como postei ontem, e já cria apaga e mostra a matriz numerada e lê o valor certinho da linha de comando se tiver algum, e assume 5 se vier errado ou nada:

int main(int argc, char** argv)
{
    const char* msg[] = {
        "numero invalido", "diagonal principal preenchida",
        "não existe espaco acima da diagonal principal",
        "não existe espaco abaixo da diagonal principal"};
    const int  limite  = 100 * 1000;  // 5 digitos no maximo
    const long semente = 20221115;    // para o gerador

    unsigned ordem = 5;  // matriz 5x5 padrão
    unsigned val   = 0;
    if (argc > 1)
    {
        val = atoi(argv[1]);
        if ((val > 1) && (val < 11)) ordem = val;
    };
    printf("Usando matriz [%lux%lu]\n", ordem, ordem);
    Matriz* tst = cria(ordem);
    mostra(tst, "Testando a matriz: ");
    tst = apaga(tst);
}

E já tem as mensagens esperadas.

Imagine uma função

	int preenche(Matriz* mtr)

Dentro da Matriz já tem a ordem e os números, então será que esse programa funcionaria:

int main(int argc, char** argv)
{
    const long semente = 20221115;  // para o gerador
    srand(semente);                 // prepara o gerador

    unsigned ordem = 5;  // matriz 5x5 padrão
    unsigned val   = 0;
    if (argc > 1)
    {
        val = atoi(argv[1]);
        if ((val > 1) && (val < 11)) ordem = val;
    };
    printf("Usando matriz [%lux%lu]\n", ordem, ordem);
    Matriz* tst = cria(ordem);
    mostra(tst, "\n[Matriz antes de ser preenchida]\n");
    preenche(tst);
    mostra(tst, "\n[Matriz preenchida]\n");
    tst = apaga(tst);
}

Sim, funcionaria. Uma linha a mais. A vantagem de escrever em torno dos dados

arfneto · 18 de novembro de 2022

Uma saída para um hipotético programa desses, para ordem 10 podia ser (sem as dezenas de mensagens para os números inválidos) usando as mesmas funções do programa anterior:

[Matriz antes de ser preenchida]
Matriz [10x10]
    1     2     3     4     5     6     7     8     9    10
   11    12    13    14    15    16    17    18    19    20
   21    22    23    24    25    26    27    28    29    30
   31    32    33    34    35    36    37    38    39    40
   41    42    43    44    45    46    47    48    49    50
   51    52    53    54    55    56    57    58    59    60
   61    62    63    64    65    66    67    68    69    70
   71    72    73    74    75    76    77    78    79    80
   81    82    83    84    85    86    87    88    89    90
   91    92    93    94    95    96    97    98    99   100


Preenchendo matriz [10x10]: 10 valores na diagonal, 45 acima, 45 abaixo


diagonal principal preenchida
não existe espaco acima da diagonal principal
não existe espaco abaixo da diagonal principal

[Matriz preenchida]
Matriz [10x10]
  670   418   286   154   671    99   484   682    77   231
  169   280   495   924   638   220   396   605   330   638
  676   728   570   154   451   451   165   561   968   440
  169   364    26   140   715   704   495   352   473    99
  728   585   702   975   260   473   484   110   297   440
  169   702    13   299   494   705   770   924   858   275
  533    78   156   104   390   416    55   209   891   264
  663   754   117    65   325   767   845   480   121   121
  624   169   533   611   325   455   104   559   810   495
  338   611   533   598   832   247   676   611   585   250

Apaga matriz [10x10]

Ou para 3x3 com as mensagens normais

Usando matriz [3x3]

[Matriz antes de ser preenchida]
Matriz [3x3]
    1     2     3
    4     5     6
    7     8     9


Preenchendo matriz [3x3]: 3 valores na diagonal, 3 acima, 3 abaixo


        317: numero invalido
        948: numero invalido
        734: numero invalido
        382: numero invalido
        877: numero invalido
        927: numero invalido
        281: numero invalido
        918: numero invalido
        578: numero invalido
        19: numero invalido
        821: numero invalido
        882: numero invalido
        857: numero invalido
diagonal principal preenchida
        149: numero invalido
        116: numero invalido
        433: numero invalido
        541: numero invalido
        959: numero invalido
não existe espaco abaixo da diagonal principal
        728: numero invalido
        82: numero invalido
        857: numero invalido
        705: numero invalido
não existe espaco acima da diagonal principal
        286: numero invalido

[Matriz preenchida]
Matriz [3x3]
  480   418    55
  169   810   286
  676   728   250

Apaga matriz [3x3]

IgorS10 · 21 de novembro de 2022

@arfneto Então, fiz o loop com o "for" mas não deu ainda, no printf só exibe a mensagem "mat [i] [j]" na matriz 5x5 já feita. Teria que ser três "for" então, um pra diagonal principal, outro pro acima e outro pro abaixo ?

arfneto · 21 de novembro de 2022

@IgorS10 Eu te mostrei como fazer o programa, certinho, passo a passo em 3 programas. E te mostrei o que era importante fazer. E te mostrei a saída dos programas.

E escrevi a função Preenche() que faz o que? Preenche a matriz todinha, certinho, com um loop só. Como eu te disse pra fazer.

E mostrei a saída dos programas, para 3x3 ou 20x20 elementos.

E aí você pergunta:

8 horas atrás, IgorS10 disse:

fiz o loop com o "for" mas não deu ainda, no printf só exibe a mensagem "mat [i] [j]" na matriz 5x5 já feita. Teria que ser três "for" então, um pra diagonal principal, outro pro acima e outro pro abaixo

O que vou responder?

Não posso adivinhar o que fez em seu programa já que não colocou o código aqui
Não, não precisa de 3 loops porque eu já te mostrei aqui. Você já tinha escrito

Em 18/11/2022 às 01:17, IgorS10 disse:

Um loop ? Sério ?

E eu te mostrei que não era preciso.
Pode usar for, do/while, while ou goto. Tanto faz o que usa para o loop

Eu comentei o código passo a passo. Rodou em sua máquina? Leu ao menos? Tem alguma dúvida?

O código de novo:

E o código dentro de cada if é simples e está separado e comentado no tópico acima, onde eu mostrei o programa inteiro comentado.

Sugiro muito escrever como eu mostrei. Em 3 fases. Levou minutos para começar a testar. E rodou certinho da primeira vez. E pode usar o código para gerar e mostrar e apagar qualquer tipo de matriz.