C Matriz aleatoria em C encontrar maior valor

itstalisson · 30 de junho de 2021

Preciso de ajuda em um exercicio com matriz aleatória, consegui gerar a matriz usando o rand e o time do computador

porém falta "Encontre então o valor do menor elemento da linha em que se encontra o maior elemento da matriz. Mostre a matriz, o maior valor, sua linha e o menor valor da linha encontrada"

alguém consegue me ajudar?

segue o código

#include <stdio.h>

#include <stdlib.h>

#include <time.h>



int main() {



    int i, j, mat1[4][4] = {0,0,0,0,0,0,0,0,0};



    srand(time(NULL));



    for(i = 0; i < 4; i++){

        for(j = 0; j < 4; j++){

            mat1[i][j] = rand() %1000;

        }

    }



    for(i = 0; i < 4; i++){

        for(j = 0; j < 4; j++)

            printf("%5d ", mat1[i][j]);

        printf("\n");

    }



    printf("\n--> %d\n", RAND_MAX);



    return 0;

}

Midori · 30 de junho de 2021

@itstalisson Inicie as variáveis com zero e no primeiro loop pegue o maior valor e a linha dele. Isso pode ser feito assim no loop interno,

if(mat1[i][j] > maior){
    maior = mat1[i][j];
    linha = i;
}

Depois no outro loop interno (onde você mostra os elementos da matriz), pegue o menor valor quando i for igual a linha do maior elemento.

itstalisson · 30 de junho de 2021

eu tentei desse jeito mas ainda não esta dando certo, alguem pode me ajudar

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

int main() {

    int i, j, maior, menor, mat[4][4] = {0,0,0,0,0,0,0,0,0};

    srand(time(NULL));

    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++){
            mat[i][j] = rand() %1000;
        }
    }

    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++)
        mat[i][j] = rand() %1000;
        scanf("%d",&mat[i][j]);
         if(mat[i][j]<menor){
            menor=mat[i][j];
           }
           if(mat[i][j]>maior){
            maior=mat[i][j];
           }
            printf("%d ", mat[i][j]);
        printf("\n");
        printf("o menor numero e:[%d]",menor);
        printf("o maior numero e:[%d]",maior);
    }



    return 0;
}

@Midori eu tentei desse jeito

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

int main() {

    int i, j, maior, menor, mat[4][4] = {0,0,0,0,0,0,0,0,0};

    srand(time(NULL));

    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++){
            mat[i][j] = rand() %1000;
        }
    }

    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++)
        mat[i][j] = rand() %1000;
        scanf("%d",&mat[i][j]);
         if(mat[i][j]<menor){
            menor=mat[i][j];
           }
           if(mat[i][j]>maior){
            maior=mat[i][j];
           }
            printf("%d ", mat[i][j]);
        printf("\n");
        printf("o menor numero e:[%d]",menor);
        printf("o maior numero e:[%d]",maior);
    }



    return 0;
}

Midori · 30 de junho de 2021

@itstalisson Desta forma que comentei como podia ser feito,

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

int main(){
    int i, j, mat1[4][4];
    int menor = 0;
    int maior = 0;
    int linha = 0;
    srand(time(NULL));

    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++){
            mat1[i][j] = rand() %1000;
            if(mat1[i][j] > maior){
                maior = mat1[i][j];
                linha = i;
            }
        }
    }

    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++){
            if(i == linha){
                if(j == 0){
                    menor = mat1[i][j];
                }
                if(mat1[i][j] < menor){
                    menor = mat1[i][j];
                }
            }
            printf("%5d ", mat1[i][j]);
        }
        printf("\n");
    }
    printf("\n--> %d, %d, %d\n", maior, menor, linha);
    return 0;
}

arfneto · 30 de junho de 2021

5 horas atrás, Midori disse:

Inicie as variáveis com zero e no primeiro loop pegue o maior valor e a linha dele. Isso pode ser feito assim

Cuidado: trata-se de uma matriz de int e os valores podem ser negativos. O fato de rand() retornar um valor positivo é circunstancial e é melhor não levar em conta e fazer o simples e considerar que um int é, digamos, um int. matriz aleatória não implica em rand(). Outros geradores de números aleatórios podem retornar valores entre INT_MIN e INT_MAX, o intervalo de variação para um int em C.

@itstalisson O que pretende com esse scanf()?

  for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++)
        mat[i][j] = rand() %1000;
        scanf("%d",&mat[i][j]);
         if(mat[i][j]<menor){
// ...

Use as variáveis de controle do for DENTRO do for. NUNCA fora a menos que a lógica exija. E nunca use globais com nomes ingênuos como i e j, caso aqui. Isso é um desastre. Só gera erro e por isso é proibido em toda parte, escolas e empresas.

Escreva o simples

  for(int i = 0; i < 4; i+=1){
        for(int j = 0; j < 4; j++)
        mat[i][j] = rand() %1000;
        scanf("%d",&mat[i][j]);
         if(mat[i][j]<menor){
//...

Qual a razão disso:

for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++){
            mat1[i][j] = rand() %1000;
        }
    }

    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++)
            printf("%5d ", mat1[i][j]);
        printf("\n");
    }

A matriz não vai mudar sozinha entre um loop e outro. Para que dois então? Estamos numa época de "nuvem" em que o processamento é pago por instruções executadas e espaço utilizado

Esse loop faz a mesma coisa:

for( int i = 0; i < 4; i+=1)
{
    for(int j = 0; j < 4; j+=1)
    {
        mat1[i][j] = rand() %1000;
        printf("%5d ", mat1[i][j]);
    }
    printf("\n");
}

Evite a todo custo coisas como esse 4 aí. Use uma variável, uma constante, um define, qualquer coisa. Entenda que se mudar de 4 para 5 tem que sair pelo programa alterando milhões de linhas. A toa. Se previna e use variávies.

Coisas como:

#define			DIM		4
  
  const int dim = 4; // dimensao em uso

tornam sua vida mais simples: a dimensão está marcada em um lugar só, só um lugar para conferir e alterar. E marcado como const assim não pode alterar sem querer... Use um #define apenas quando for declarar vetores. Use const sempre que possível. E use unsigned para valores que sabe que não podem ser negativos...

6 horas atrás, itstalisson disse:

time do computador

Não precisa de time() para isso. Na verdade era até melhor usar um valor constante, como

      srand(210630); // seed para o gerador rand()

Ansi C · 30 de abril de 2024

@itstalisson

Boa Terde!

Nessa sua tentativa, a matriz perdeu sentido, acredito em guardar os índices da matriz e não copiar seus valores. Por exemplo

C'11 - gcc'11.4

#include <stdio.h> /* Include the header file for input and output */
int main (void) {
  size_t a[2]= {0}/*   sendo o suposto maior elemento dum unitário */;
  int matriz [] [4]= {
    {1,2,3,4} , {5,-6,7,8} ,
    {9,0,-1,2} , {6,5,7,8}};
  for (size_t ai= 0 ; ai<sizeof matriz/ sizeof(matriz[0]) ; ++ai) {
  for (size_t aj= 0 ; aj<sizeof matriz[0]/ sizeof(matriz[0][0]) ; ++aj) {
      if (matriz[ai][aj]>matriz[a[0]][a[1]]) a[0]= ai , a[1]= aj;
      }}
  size_t aij= 0;
  for (size_t aj= 0 ; aj<sizeof matriz[0]/ sizeof(matriz[0][0]) ; ++aj) {
    if (matriz[a[0]][aj]<matriz[a[0]][aij]) aij= aj;
    }
  putchar ('\n');
  printf ("%s%d%c","O maior elemento da matriz é: ",matriz[a[0]][a[1]],'\n');
  printf ("%s%d%c","O menor elemento na linha do maior elemento é: "        ,
                                                           matriz[a[0]][aij],
                                                                       '\n');
  /* ... */
  return 0;
  }

AQUI são os índices que auxiliam a produção. Para mim, isso confere com enunciado — se conhece algum refinamento, então aplique-o.

arfneto · 30 de abril de 2024

36 minutos atrás, Ansi C disse:

Para mim, isso confere com enunciado

Em 30/06/2021 às 13:25, itstalisson disse:

ajuda em um exercicio com matriz aleatória, consegui gerar a matriz usando o rand e o time do computador

porém falta "Encontre então o valor do menor elemento da linha em que se encontra o maior elemento da matriz. Mostre a matriz, o maior valor, sua linha e o menor valor da linha encontrada"

alguém consegue me ajudar?

37 minutos atrás, Ansi C disse:

se conhece algum refinamento, então aplique-o.

Talvez deva rever... Não chamaria de refinamento, mas o enunciado deixa claro que se trata de uma matriz de números aleatórios e não constantes.

Salvar os índices numa matriz que é usada uma única vez não é provavelmente "auxiliar a produção". Apenas usa mais tempo e memória e letrinhas. No fundo sequer precisa dos índices.

Ansi C · 30 de abril de 2024

@arfneto

Defina aleatório, por favor?

12 minutos atrás, arfneto disse:

Salvar os índices numa matriz que é usada uma única vez não é provavelmente "auxiliar a produção". Apenas usa mais tempo e memória e letrinhas. No fundo sequer precisa dos índices

Observe com materialidade, sem fetiches: notará que é um exercício das matrizes. E que suas palavras não fazem sentido.

12 minutos atrás, arfneto disse:

Não chamaria de refinamento

E da?

12 minutos atrás, arfneto disse:

"auxiliar a produção"

Explique-me, o que significa isso?

12 minutos atrás, arfneto disse:

No fundo sequer precisa dos índices.

"No fundo"?

O que isso diz? Explique-se por favor!

arfneto · 30 de abril de 2024

Em 30/06/2021 às 13:25, itstalisson disse:

matriz aleatória, consegui gerar a matriz usando o rand

1 hora atrás, Ansi C disse:

Defina aleatório, por favor?

Esse não é o forum para definir aleatório mas, de https://www.dicio.com.br/aleatorio/

1 hora atrás, Ansi C disse:

int matriz [] [4]= {
    {1,2,3,4} , {5,-6,7,8} ,
    {9,0,-1,2} , {6,5,7,8}};

E isso não parece condizer com o enunciado.

1 hora atrás, Ansi C disse:

AQUI são os índices que auxiliam a produção. Para mim, isso confere com enunciado — se conhece algum refinamento, então aplique-o

1 hora atrás, Ansi C disse:

1 hora atrás, arfneto disse:

Não chamaria de refinamento

E da?

Eu não chamaria de refinamento uma "aplicação" para fazer sua solução condizente com o enunciado. Seria uma correção.

1 hora atrás, Ansi C disse:

"No fundo"?

O que isso diz? Explique-se por favor!

Memória é algo linear. Em C há apenas arrays, e arrays de arrays e assim por diante. Uma "mariz 4x4" é só uma região contínua na memória. Pelo enunciado só é preciso definir a linha em que está o maior elemento, para depois identificar o menor valor nessa linha. Não precisa de índices para isso.

Vou me ater ao tópico e enunciado, de 2021.

Ansi C · 30 de abril de 2024

30 minutos atrás, arfneto disse:

Esse não é o forum para definir aleatório

Somente para aqueles que não são capazes e que dizem coisas como essa frase acima.

30 minutos atrás, arfneto disse:

Eu não chamaria de refinamento uma "aplicação" para fazer sua solução condizente com o enunciado. Seria uma correção.

A solução é condizente com enunciado.

Aquela matriz por definição é aleatório!

Ainda é impossível saber ou identificar os critérios e processos lógicos/químicos/físicos que acontecem no meu cérebro enquanto escolhia os valores para defini-la (a matriz).

Por razão disso, aleatório.

E não confunde aleatório com pseudoaleatório.

30 minutos atrás, arfneto disse:

Memória é algo linear. Em C há apenas arrays, e arrays de arrays e assim por diante. Uma "mariz 4x4" é só uma região contínua na memória. Pelo enunciado só é preciso definir a linha em que está o maior elemento, para depois identificar o menor valor nessa linha. Não precisa de índices para isso.

Sei de tudo isso! São temas lidos nos tópicos de apontamentos de matrizes e demonstram-se nos exercícios conforme o exemplo que proponho (de boa fé) a essa discussão.

***

arfneto · 30 de abril de 2024

Citação

Preciso de ajuda em um exercicio com matriz aleatória, consegui gerar a matriz usando o rand e o time do computador
porém falta "Encontre então o valor do menor elemento da linha em que se encontra o maior elemento da matriz. Mostre a matriz, o maior valor, sua linha e o menor valor da linha encontrada"
alguém consegue me ajudar?

Passados quase 3 anos acho que uma resposta mais completa pode ajudar a outros

O programa original

int main()
{
    int i, j, mat1[4][4] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

    srand(time(NULL));

    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++)
            mat1[i][j] = rand() % 1000;
    }

    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++) printf("%5d ", mat1[i][j]);
        printf("\n");
    }
    printf("\n--> %d\n", RAND_MAX);
    return 0;
}

O programa não está nada bom, e não fez quase nada do exercício.

declare uma variável por linha. Linhas são grátis.
declare as variáveis de controle do loop DENTRO do loop
nunca use globais, em especial com esses nominhos ingênuos tipo `i` e `j`.
não precisa de `time`. E `time` é uma função e está em `stdlib`. Não é "do computador"
não precisa de `srand` mas se quer usar seria melhor usar um valor conhecido, já que está testando o programa e se imagina que vá completar isso alguma hora. Repetir os valores até ter certeza é vantagem.
não há razão alguma para imprimir `RAND_MAX` que é uma constante
se não vai usar os argumentos da linha de comando declare `main` como `main(void)`

O enunciado é fraco e nada diz sobre limites e dimensões.

## um exemplo ##

Citação

Mostre a matriz, o maior valor, sua linha e o menor valor da linha encontrada

Então sabe um minimo do que deve fazer. Considere funções que pode usar e testar em separado. É muito mais simples. Precisa no minimo

preencher a matriz com números aleatórios
mostrar a matriz
encontrar o máximo e mínimo como pedido e mostrar

### preencher a matriz ###

Considere esse exemplo

int define(int M[][DIM_N],int minimo,int maximo)
{
    int* p = (int*)M;
    if (minimo > maximo) maximo = minimo + 1000;
    for (size_t i = 0; i < DIM_M * DIM_N; i += 1)
        *(p + i) = minimo + rand() % (maximo - minimo + 1);
    return 0;
}

Tem só 4 linhas e preenche a matriz com valores aleatórios entre `minimo` e `maximo` inclusive.

No programa exemplo (código ao final), que faz dois testes, é chamada assim

    define(mat,-1000,1000);
    // e 
    define(mat,0,100); // outro teste

### mostrando a matriz ###

int mostra(int M[][DIM_N], const char* msg)
{
    if (msg != NULL) printf("%s", msg);
    printf("matriz [%i,%i]\n\n", DIM_M, DIM_N);
    for (size_t i = 0; i < DIM_M; i += 1)
    {
        for (size_t j = 0; j < DIM_N; j += 1)
            printf("%5i  ", M[i][j]);
        printf("\n");
    }
    return 0;
}

Essa função faz o simples e mostra a matriz. Os valores de máximo e mínimo não são mostrados aqui porque é muito possível se querer mostrar a matriz sem mostrar esses valores. A função aceita uma mensagem opcional, poruqe ajuda nos testes e elimina clássicas chamadas a printf() para identificar cada teste.

### calculando o máximo e mínimo como pedido ###

Isso é trivial, basta um loop pelos índices para achar o maior valor e mostrar junto com o número da linha. Sabendo o número da linha é trivial em um outro loop identificar o menor valor e mostrar.

Eis uma possível função para identificar esses valores, sem usar índices:

int minimo(int M[][DIM_N])
{
    int* p      = (int*)M;
    int* limite = (int*)M;  // limite eh o maior
    for (size_t i = 1; i < DIM_M * DIM_N; i += 1)
        if (*limite < *(p + i)) limite = p + i;
    // em que linha esta isso?
    int linha = (int)(limite - (int*)M) / DIM_N;
    printf(
        "\n\tMaior valor = %i [na linha %i]\n", *limite,
        linha);
    // qual o menor nessa linha?
    p      = p + linha * DIM_N;
    limite = p;  // limite agora eh o menor
    for (size_t i = 1; i < DIM_N; i += 1)
        if (*limite > *(p + i)) limite = p + i;
    printf("\tMenor valor nessa linha = %i\n", *limite);
    return *limite;
}

Usar os índices e a notação `[a][b]` é trivial.

Uma implementação bem linear poderia ser essa:

int minimo_i(int M[][DIM_N])
{
    int    maior = M[0][0];
    size_t i     = 0;
    size_t linha = 0;
    for (i = 0; i < DIM_M; i += 1)
        for (int j = 0; j < DIM_N; j += 1)
            if (maior < M[i][j]) maior = M[i][j], linha = i;
    printf(
        "\n\tMaior valor = %i [na linha %llu]\n", maior,
        linha);
    int menor = M[linha][0];
    for (size_t j = 1; j < DIM_N; j += 1)
        if (menor > M[linha][j]) menor = M[linha][j];
    printf("\tMenor valor nessa linha = %i\n", menor);
    return menor;
}

### main para o exemplo ###

Essa função no exemplo usa matrizes 5x8

int main(void)
{
    int  mat[DIM_M][DIM_N] = {0};
    int* p         = (int*)mat;
    srand(240429);
    define(mat, -1000, 1000);
    mostra(mat, "\n\nintervalo: [-1000,1000]\t");
    minimo(mat);
    minimo_i(mat);
    define(mat, 0, 100);  // outro teste
    mostra(mat, "\n\nintervalo: [0,100]\t");
    minimo(mat);
    minimo_i(mat);
    return 0;
}

### saida do exemplo para uma matriz 5x8 ###


intervalo: [-1000,1000] matriz [5,8]

  499   -244   -491   -186   -349   -330     28    605
 -625    305    -47    360    720    862    744   -365
  313    -51    225   -341   -477    947    698   -701
 -987   -344   -518    331    190    845   -270   -212
  318   -563   -667    111   -412    715    299    371

        Maior valor = 947 [na linha 2]
        Menor valor nessa linha = -701

        Maior valor = 947 [na linha 2]
        Menor valor nessa linha = -701


intervalo: [0,100]      matriz [5,8]

   42     66     17     87     63     79     75     23
   63     49     62     74     39     71     19     34
   42      7     12     21     88     70     60     71
   31     85     22     62     81     12     26      9
   95     22     69     44     48     63     39     13

        Maior valor = 95 [na linha 4]
        Menor valor nessa linha = 13

        Maior valor = 95 [na linha 4]
        Menor valor nessa linha = 13

Note que o programa chama as duas funções que mostram o máximo e o mínimo. É um teste afinal.

### o programa completo ###

#define DIM_M (int)5
#define DIM_N (int)8

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

int minimo(int M[][DIM_N]);
int minimo_i(int M[][DIM_N]);
int define(int M[][DIM_N], int, int);
int mostra(int M[][DIM_N], const char*);

int main(void)
{
    int  mat[DIM_M][DIM_N] = {0};
    int* p         = (int*)mat;
    srand(240429);
    define(mat, -1000, 1000);
    mostra(mat, "\n\nintervalo: [-1000,1000]\t");
    minimo(mat);
    minimo_i(mat);
    define(mat, 0, 100);  // outro teste
    mostra(mat, "\n\nintervalo: [0,100]\t");
    minimo(mat);
    minimo_i(mat);
    return 0;
}

int mostra(int M[][DIM_N], const char* msg)
{
    if (msg != NULL) printf("%s", msg);
    printf("matriz [%i,%i]\n\n", DIM_M, DIM_N);
    for (size_t i = 0; i < DIM_M; i += 1)
    {
        for (size_t j = 0; j < DIM_N; j += 1)
            printf("%5i  ", M[i][j]);
        printf("\n");
    }
    return 0;
}

int minimo(int M[][DIM_N])
{
    int* p      = (int*)M;
    int* limite = (int*)M;  // limite eh o maior
    for (size_t i = 1; i < DIM_M * DIM_N; i += 1)
        if (*limite < *(p + i)) limite = p + i;
    // em que linha esta isso?
    int linha = (int)(limite - (int*)M) / DIM_N;
    printf(
        "\n\tMaior valor = %i [na linha %i]\n", *limite,
        linha);
    // qual o menor nessa linha?
    p      = p + linha * DIM_N;
    limite = p;  // limite agora eh o menor
    for (size_t i = 1; i < DIM_N; i += 1)
        if (*limite > *(p + i)) limite = p + i;
    printf("\tMenor valor nessa linha = %i\n", *limite);
    return *limite;
}

int minimo_i(int M[][DIM_N])
{
    int    maior = M[0][0];
    size_t i     = 0;
    size_t linha = 0;
    for (i = 0; i < DIM_M; i += 1)
        for (int j = 0; j < DIM_N; j += 1)
            if (maior < M[i][j]) maior = M[i][j], linha = i;
    printf(
        "\n\tMaior valor = %i [na linha %llu]\n", maior,
        linha);
    int menor = M[linha][0];
    for (size_t j = 1; j < DIM_N; j += 1)
        if (menor > M[linha][j]) menor = M[linha][j];
    printf("\tMenor valor nessa linha = %i\n", menor);
    return menor;
}

int define(int M[][DIM_N], int minimo, int maximo)
{
    int* p = (int*)M;
    if (minimo > maximo) maximo = minimo + 1000;
    for (size_t i = 0; i < DIM_M * DIM_N; i += 1)
        *(p + i) = minimo + rand() % (maximo - minimo + 1);
    return 0;
}

Ansi C · 1 de maio de 2024

3 horas atrás, arfneto disse:

int define(int M[][DIM_N], int minimo, int maximo)
{
    int* p = (int*)M;
    if (minimo > maximo) maximo = minimo + 1000;
    for (size_t i = 0; i < DIM_M * DIM_N; i += 1)
        *(p + i) = minimo + rand() % (maximo - minimo + 1);
    return 0;
}

Pseudoaleatório.

3 horas atrás, arfneto disse:

Passados quase 3 anos acho que uma resposta mais completa pode ajudar a outros

Sim, porém, para aqueles que continuam compreendendo matrizes, não ajudará em nada, pelo contrário confundirá ainda mais com todas essas passagens por referência, ponteiros e nomes curtos e funções complicantes.

E demais para um exercício iniciante das matrizes, mas se a intenção foi demonstrou conhecimento, então… boa resposta parabéns

arfneto · 1 de maio de 2024

1 hora atrás, Ansi C disse:

Sim, porém, para aqueles que continuam compreendendo matrizes, não ajudará em nada, pelo contrário confundirá ainda mais com todas essas passagens por referência, ponteiros e nomes curtos e funções complicantes.

E demais para um exercício iniciante das matrizes, mas se a intenção foi demonstrou conhecimento, então… boa resposta parabéns

C não tem passagem por referência. Apenas por valor. Todo array em C é um ponteiro para uma área de memória de um certo tamanho. Na literatura procure por "array to pointer decay".

Provavelmente, mesmo sendo um forum onde pode ir escrevendo o que quiser, não devia colocar SUA opinião como definitiva sobre o que seja "confuso" ou "complicante".

Deve mesmo ser confuso chamar a matriz de M e o minimo de minimo e o maximo de maximo, como está aí acima...

main() com 10 linhas parece bem complexo com essas funções de nomes curtos e enigmáticos, como mostra, define e minimo:

    define(mat, -1000, 1000);
    mostra(mat, "\n\nintervalo: [-1000,1000]\t");
    minimo(mat);
    minimo_i(mat);

Acho que entende que minimo() sem usar indices é um exemplo e que minimo_i() é o trivial para encontrar os valores que o enunciado pede, ou não?

int minimo_i(int M[][DIM_N])
{
    int    maior = M[0][0];
    size_t i     = 0;
    size_t linha = 0;
    for (i = 0; i < DIM_M; i += 1)
        for (int j = 0; j < DIM_N; j += 1)
            if (maior < M[i][j]) maior = M[i][j], linha = i;
    printf(
        "\n\tMaior valor = %i [na linha %llu]\n", maior,
        linha);
    int menor = M[linha][0];
    for (size_t j = 1; j < DIM_N; j += 1)
        if (menor > M[linha][j]) menor = M[linha][j];
    printf("\tMenor valor nessa linha = %i\n", menor);
    return menor;
}

Você que está lendo isso e tem a mesma dúvida de @Ansi C entenda que a matriz no exemplo é suposta MxN, e assim essas constantes complicadas DIM_M e DIM_N dão a dimensão que a matriz vai ter no programa. Seria possível definir dinâmicamente ou usar uma matriz limite como 10x10, mas esse é um programa exemplo para iniciantes.

É pelo valor dessas constantes que o programa usa uma matriz 5x8.

Se não ficou claro com esses nomes estranhos,

mostra() mostra a matriz na tela e aceita um título. É uma comodidade como pode ver no exemplo, Evita que nos testes use mensagens para explicar um teste ou outtro.

define() apenas carrega a matriz com valores aleatórios entre minimo e maximo inclusive. É por isso que os argumentos são minimo e maximo.

minimo() é uma função que mostr na tela os valores que o programa pede. Apenas a título de exemplo tem 2 versões. A primeira não usa índices [a][b] e a segunda, minimo_i() usa o trivial. Claro que pode usar apenas uma e apagar a outra.

1 hora atrás, Ansi C disse:

Pseudoaleatório.

Obrigado por clarificar esse conceito. Pode parecer um tanto pedante você insistir nisso, mas assim é: rand() gera números pseudo-aleatórios!!!

Ansi C · 1 de maio de 2024

22 minutos atrás, arfneto disse:

C não tem passagem por referência. Apenas por valor. Todo array em C é um ponteiro para uma área de memória de um certo tamanho. Na literatura procure por "array to pointer decay".

Eu sei, às vezes chama os ponteiros de referência e os endereços (valores neles) de passagem.

A propósito, isso não é novidade, é a primeira vez que tenho que explicar. Até os iniciantes conhecem esses termos.

22 minutos atrás, arfneto disse:

Deve mesmo ser confuso chamar a matriz de M e o minimo de minimo e o maximo de maximo, como está aí acima...

Claro que é.

Funções, ponteiros, gerador de números pseudoaleatórios, tudo de uma vez para uma discussão de iniciantes das matrizes; Ajuda pouco ou quase nada no cerne da questão, e repito são as matrizes e não funções, ponteiros etc,

Mas essa é somente a minha opinião.

22 minutos atrás, arfneto disse:

Obrigado por clarificar esse conceito. Pode parecer um tanto pedante você insistir nisso, mas assim é: rand() gera números pseudo-aleatórios!!!

Se parece pedante, é porque te falta leitura.

É fácil de resolver, leia mais que termos e palavras deixam de ser pedantes.

****