Ir ao conteúdo
Regras do Clube do Hardware

C Encontre o maior valor de cada linha e o armazene em um vetor

Michel De Lima

Por Michel De Lima
em C/C#/C++

 Compartilhar

Posts recomendados

Michel De Lima
 

Michel De Lima

Postado
Postado

Olá, Estou com uma duvida para resolver esse exercício, como posso calcular o maior valor de cada linha e o armazene em um vetor de uma matriz 3x4?

Exercicio:

Faça um programa em C que leia uma matriz NxM de valores reais,
encontre o maior valor de cada linha e o armazene em um vetor.
Encontre também o maior valor da matriz e utilize para dividir
todos os elementos da matriz por ele.

Até agora consegui desenvolver isso: 

#include <stdio.h> // biblioteca de funções de entrada/saída
#include <stdlib.h> // biblioteca de funções de uso geral
#include <locale.h> //biblioteca de funções para idiomas
#define tamL 3
#define tamC 4

int main()
{
    //variáveis
    float matriz[tamL][tamC],maiorL,maior;
    int l,c;

    setlocale(LC_ALL, "Portuguese"); //Idioma em português
    fflush(stdin); //limpar o buffer do teclado
    system("color 2f"); //coloca cor no sistema

    printf("-------------------------------------------------\n");
    printf("---------------- Exercício ----------------------\n");
    printf("-------------------------------------------------\n");
    printf("- Digite valores para os elementos da matriz 3x4:\n");

    for (l=0; l<tamL; l++)
        for (c=0; c<tamC; c++)
        {
            printf ("-> Elemento[%d][%d] = ", l, c);
            scanf ("%f", &matriz[l][c]);
        }

    printf("-------------------------------------------------\n");

    printf("-> Matriz gerada:\n");
    for(l = 0; l < tamL; l++)
    {
        for(c = 0; c < tamC; c++)
        {
            printf(" %.1f  ", matriz[l][c]);
        }
        printf("\n");
    }

    printf("-------------------------------------------------\n");

    //encontrar maior valor de cada linha
    printf("-> Maior valor de cada linha:\n");
    maior = matriz[tamL][tamC];
    for(c=0; c<tamC; c++)
    {
        for(l=0; l<tamL; l++)
        {
            if(matriz[l][c] > maiorL)
            {
                maiorL = matriz[l][c];
            }
        }
    }
    printf(" - Resultado = %1.f\n",maiorL);

    printf("\n-------------------------------------------------\n");

    printf("-> Maior valor da matriz:\n");

    //encontrar maior valor
    maior = matriz[tamL][tamC];
    for(l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
            if(matriz[l][c] > maior)
            {
                maior = matriz[l][c];
            }
        }
    }
    printf(" - Resultado = %1.f\n",maior);

    printf("-------------------------------------------------\n");
  return 0;
  }

 

  • Obrigado 1
devair1010
 

devair1010

Postado
Postado

@Michel De Lima      o enunciado diz para ler a matriz ,  então use mesmo o scanf , mas apenas para testar insira os valores na matriz no momento da criação , e assim não precisa perder tempo digitando no teclado tais números ,  e verificar o maior de cada linha e o maior da matriz e também inserir em um vetor (que você ainda não colocou nesse seu código ) ,  pode ser feito em apenas dois loop's  ,  e seu código ficou assim  : 

#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <locale.h>
#define tamL 3
#define tamC 4
int main()
{
    float matriz[tamL][tamC] =
          {{ 1 , 2 , 3 , 4 } ,
           { 5 , 6 , 7 , 8 } ,
           { 9 ,10 ,11 ,12 } ,
          },vetor[3], maiorL , 
          maior_da_matriz;
    int   l,c,k=0;

    setlocale(LC_ALL, "Portuguese");             ///  Idioma em português
    fflush(stdin);                               ///  limpar o buffer do teclado
    system("color 2f");                          ///  coloca cor verde com letras brancas , no sistema

    printf("-------------------------------------------------\n");
    printf("---------------- Exercício ----------------------\n");
    printf("-------------------------------------------------\n");
    printf("- Digite valores para os elementos da matriz 3x4:\n");

    for (l=0; l<tamL; l++)
    {
        for (c=0; c<tamC; c++)
        {
            printf ("-> Elemento[%d][%d] = %5.1f\n", l, c, matriz[l][c]);
            /// scanf ("%f", &matriz[l][c]);
        }
    }
    printf("-------------------------------------------------\n");
    printf("-> Matriz gerada:\n");
    maior_da_matriz = matriz[0][0];              /// pega o 1º elemento da 1ª linha da  matriz
    for(l = 0; l < tamL; l++)                    /// percorre as linhas da matriz
    {
        maiorL = matriz[l][0];                   /// pega o 1º elemento de cada linha da  matriz
        for(c = 0; c < tamC; c++)                /// poercorre as colunas da matriz
        {
            if(matriz[l][c] > maiorL)            /// verifica se é maior
                maiorL = matriz[l][c];           /// guarda o maior
            if( matriz[l][c] > maior_da_matriz)  /// verifica se é maior
                maior_da_matriz = matriz[l][c];  /// guarda o maior
            printf(" %5.1f  ", matriz[l][c]);    /// escreve os valores da matriz
        }
        printf("<-- %5.1f maior VaLor dessa Linha\n",maiorL); /// escreve o maior de cada linha da matriz
        vetor[k] = maiorL;                       /// guarda no vetor o maior de cada Linha da matriz
        k++;                                     /// incrementa a posição no vetor
    }
    printf("-------------------------------------------------\n");
    //encontrar maior valor de cada linha
    printf("-> Maior valor de cada linha:\n");
    /// maior = matriz[tamL][tamC]; /// aqui vai pegar valores em posições inexistentes
                                    /// pois tamL é = 3 , e a matriz só vai de 0 até 2
                                    /// pois tamC é = 4 , e a matriz só vai de 0 até 3
/*    maiorL = matriz[0][0];
    for(c=0; c<tamC; c++)           /// esses loop's não precisam ,maiorL e maior_da_matriz
                                    /// já foram pesquisados no loop anterior
    {
        for(l=0; l<tamL; l++)
        {
            if(matriz[l][c] > maiorL)
            {
                maiorL = matriz[l][c];
            }
        }
    }

    printf(" - Resultado = %5.1f\n",maiorL); /// só vai escrever o maior da última linha
    printf("\n-------------------------------------------------\n");
    printf("-> Maior valor da matriz:\n");
    /// encontrar maior valor
    maior_da_matriz = matriz[tamL][tamC];
    for(l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
            if(matriz[l][c] > maior_da_matriz)
            {
                maior_da_matriz = matriz[l][c];
            }
        }
    }
*/
    printf(" - Resultado = %5.1f\n",maior_da_matriz);
    printf("-------------------------------------------------\n");
    printf("todos numeros da matriz divido por %5.1f\n",maior_da_matriz);
    for(l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
           printf("%5.1f / %5.1f = %5.1f  |" ,              matriz[l][c] ,
                   maior_da_matriz , matriz[l][c]  /   maior_da_matriz );
                   /// escreve os numeros divididos pelo maior da  matriz
        }
        printf("\b \n");
    }
    return 0;
}

 

Michel De Lima
 

Michel De Lima

Postado
  • Autor
Postado

Valeu!!!, programei no codeblocks, mas testei no dev, agora no dev esta saindo com caracteres errados, sabe me dizer o porque?

 

-> Maior valor de cada linha:
Linha 0 =  -1,#R
Linha 1 =  -1,#R
Linha 2 =  -1,#R
-------------------------------------------------
-> Maior valor da matriz:
 - Resultado = -1
-------------------------------------------------
-> A matriz dividida pelo maior valor encontrado:
 -1,#R   -1,#R   -1,#R   -1,#R
 -1,#R   -1,#R   -1,#R   -1,#R
 -1,#R   -1,#R   -1,#R   -1,#R
-------------------------------------------------
-> A soma dos elementos da matriz após a divisão:
 -1,#R
-------------------------------------------------
-> A transposta da matriz depois da divisão:
 -1,#R   -1,#R   -1,#R
 -1,#R   -1,#R   -1,#R
 -1,#R   -1,#R   -1,#R
 -1,#R   -1,#R   -1,#R

  • Obrigado 1
Michel De Lima
 

Michel De Lima

Postado
  • Autor
Postado

@devair1010 vou postar o código compilado no codeblocks e no devC++: 

#include <stdio.h>  // biblioteca de funções de entrada/saída
#include <stdlib.h> // biblioteca de funções de uso geral
#include <locale.h>  //biblioteca de funções para idiomas
#define tamL 3      // tamanho da linha da matriz
#define tamC 4      // tamanho da coluna da matriz
int main()
{
    //variáveis
    float matriz[tamL][tamC],trans[tamC][tamL],vetor[3],maior,soma;
    int l,c;

    setlocale(LC_ALL, "Portuguese"); //Idioma em português
    fflush(stdin); //limpar o buffer do teclado
    system("color 2f"); //coloca cor no sistema

    printf("-------------------------------------------------\n");
    printf("---------------- Exercício nº 4 -----------------\n");
    printf("-------------------------------------------------\n");
    printf("- Digite valores para os elementos da matriz 3x4:\n");

    for (l=0; l<tamL; l++)
        for (c=0; c<tamC; c++)
        {
            printf ("-> Elemento[%d][%d] = ", l, c);
            scanf ("%f", &matriz[l][c]);
        }

    printf("-------------------------------------------------\n");
    printf("-> Matriz gerada:\n");
    for(l = 0; l < tamL; l++)
    {
        for(c = 0; c < tamC; c++)
        {
            //mostra a matriz gerada
            printf(" %.2f ", matriz[l][c]);
        }
        printf("\n");
    }

    printf("-------------------------------------------------\n");

    printf("-> Maior valor de cada linha:\n");
    //encontrar maior valor de cada linha
    for (l = 0; l < tamL; l++)
    {
        vetor[l] = matriz[tamL][tamC];
        for (c = 0; c < tamC; c++)
        {
            if(matriz[l][c] > vetor[l])
            {
                vetor[l] = matriz[l][c];
            }
        }
    }
    for (l=0; l<tamL; l++)
        //mostra o vetor com o maior valor de cada linha
        printf("Linha %d =  %.2f\n", l, vetor[l]);


    printf("-------------------------------------------------\n");

    printf("-> Maior valor da matriz:\n");
    //encontrar maior valor
    maior = matriz[tamL][tamC];
    for(l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
            if(matriz[l][c] > maior)
            {
                maior = matriz[l][c];
            }
        }
    }
    //mostra o maior valor da matriz
    printf(" - Resultado = %.2f\n",maior);

    printf("-------------------------------------------------\n");

    printf("-> A matriz dividida pelo maior valor encontrado:\n");
    maior = matriz[l][c];
    for (l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
            if (matriz[l][c]>maior)
                maior = matriz[l][c];
        }
    }
    for (l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
            matriz[l][c] = matriz[l][c] / maior;
    }
    for (l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
            //mostra a matriz dividida pelo maior encontrado
            printf(" %.2f  ", matriz[l][c]);
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    printf("-> A soma dos elementos da matriz após a divisão:\n");
    soma=0;
    for(l=0; l<tamL; l++)
        for(c=0; c<tamC; c++)
            soma = soma + matriz[l][c];

    //mostra a soma depois da divisão
    printf(" %.2f  \n", soma);

    printf("-------------------------------------------------\n");

    printf("-> A transposta da matriz depois da divisão:\n");
    for(l = 0; l < tamL; l++)
    {
        for(c = 0; c < tamC; c++)
        {
            trans[c][l] = matriz[l][c];
        }
    }
    for(l = 0; l < tamC; l++)
    {
        for(c = 0; c < tamL; c++)
        {
            //mostra a transposta depois da divisão
            printf(" %.2f  ", trans[l][c]);
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    system( "PAUSE" );
    return 0;
}

 

agora, Michel De Lima disse:

@devair1010 vou postar o código compilado no codeblocks e no devC++: 

#include <stdio.h>  // biblioteca de funções de entrada/saída
#include <stdlib.h> // biblioteca de funções de uso geral
#include <locale.h>  //biblioteca de funções para idiomas
#define tamL 3      // tamanho da linha da matriz
#define tamC 4      // tamanho da coluna da matriz
int main()
{
    //variáveis
    float matriz[tamL][tamC],trans[tamC][tamL],vetor[3],maior,soma;
    int l,c;

    setlocale(LC_ALL, "Portuguese"); //Idioma em português
    fflush(stdin); //limpar o buffer do teclado
    system("color 2f"); //coloca cor no sistema

    printf("-------------------------------------------------\n");
    printf("---------------- Exercício nº 4 -----------------\n");
    printf("-------------------------------------------------\n");
    printf("- Digite valores para os elementos da matriz 3x4:\n");

    for (l=0; l<tamL; l++)
        for (c=0; c<tamC; c++)
        {
            printf ("-> Elemento[%d][%d] = ", l, c);
            scanf ("%f", &matriz[l][c]);
        }

    printf("-------------------------------------------------\n");
    printf("-> Matriz gerada:\n");
    for(l = 0; l < tamL; l++)
    {
        for(c = 0; c < tamC; c++)
        {
            //mostra a matriz gerada
            printf(" %.2f ", matriz[l][c]);
        }
        printf("\n");
    }

    printf("-------------------------------------------------\n");

    printf("-> Maior valor de cada linha:\n");
    //encontrar maior valor de cada linha
    for (l = 0; l < tamL; l++)
    {
        vetor[l] = matriz[tamL][tamC];
        for (c = 0; c < tamC; c++)
        {
            if(matriz[l][c] > vetor[l])
            {
                vetor[l] = matriz[l][c];
            }
        }
    }
    for (l=0; l<tamL; l++)
        //mostra o vetor com o maior valor de cada linha
        printf("Linha %d =  %.2f\n", l, vetor[l]);


    printf("-------------------------------------------------\n");

    printf("-> Maior valor da matriz:\n");
    //encontrar maior valor
    maior = matriz[tamL][tamC];
    for(l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
            if(matriz[l][c] > maior)
            {
                maior = matriz[l][c];
            }
        }
    }
    //mostra o maior valor da matriz
    printf(" - Resultado = %.2f\n",maior);

    printf("-------------------------------------------------\n");

    printf("-> A matriz dividida pelo maior valor encontrado:\n");
    maior = matriz[l][c];
    for (l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
            if (matriz[l][c]>maior)
                maior = matriz[l][c];
        }
    }
    for (l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
            matriz[l][c] = matriz[l][c] / maior;
    }
    for (l=0; l<tamL; l++)
    {
        for(c=0; c<tamC; c++)
        {
            //mostra a matriz dividida pelo maior encontrado
            printf(" %.2f  ", matriz[l][c]);
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    printf("-> A soma dos elementos da matriz após a divisão:\n");
    soma=0;
    for(l=0; l<tamL; l++)
        for(c=0; c<tamC; c++)
            soma = soma + matriz[l][c];

    //mostra a soma depois da divisão
    printf(" %.2f  \n", soma);

    printf("-------------------------------------------------\n");

    printf("-> A transposta da matriz depois da divisão:\n");
    for(l = 0; l < tamL; l++)
    {
        for(c = 0; c < tamC; c++)
        {
            trans[c][l] = matriz[l][c];
        }
    }
    for(l = 0; l < tamC; l++)
    {
        for(c = 0; c < tamL; c++)
        {
            //mostra a transposta depois da divisão
            printf(" %.2f  ", trans[l][c]);
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    system( "PAUSE" );
    return 0;
}

 

no codeblocks sai perfeito mas no devC++ sai: -1,#R

@devair1010 sai assim no devC++

imagem_2021-10-11_002804.png

  • Amei 1
arfneto
 

arfneto

Postado
Postado
5 horas atrás, devair1010 disse:

pode ser esse biblioteca locale , ela interfere nos códigos dos caracteres ASCII

 

locale não interfere em "códigos ASCII"

 

Se está usando Dev-C++ e Code::Blocks:

  • nenhum dos dois é um compilador. São ambientes, IDE apenas. E são os mais fracos. fracos. Talvez devesse procurar outros. 
  • o compilador é o mesmo, provavelmente o gcc. Ninguém disse em qual plataforma está compilando, nem com qual compilador, nem com quais opções de compilação.
  • Sobre o locale especificamente 
        setlocale(LC_ALL, "Portuguese");  // Idioma em português

    Não está claro sequer que esse locale exista na máquina que está usando... Se está usando linux (ou mesmo algumas maquinas com Windows) rode locale -a e vai quais locales existem de fato em sua máquina e rode locale sem o -a para saber o locale ativo.

Nesse exemplo aqui precisa disso, mas no fundo nem está usando: a razão de usar isso seria ver qual o ponto decimal em uso e avisar o infeliz que está usando o programa. Como nenhum dos programas que vi acima faz isso de nada adianta...

 

Você não pode escrever qualquer coisa para essa função, claro. Os nomes são definidos e padronizados pelo IETF. Não está claro que exista esse locale "Portuguese" ou "portuguese" . Recomendo sempre ler a documentação. Está usando Windows? Veja no painel de controle e a documentaçao. Está usando Linux? man locale ou locale -a e locale

 

Exemplo

 

Meu PBX roda Linux, e vi agora que tem esses locale em português:

  


[toninho@asterisk ~]$ locale -a | grep pt-
[toninho@asterisk ~]$ locale -a | grep pt_
pt_BR
pt_BR.iso88591
pt_BR.utf8
pt_PT
pt_PT@euro
pt_PT.iso88591
pt_PT.iso885915@euro
pt_PT.utf8
[toninho@asterisk ~]$ locale -a | grep po
polish
portuguese
[toninho@asterisk ~]$

 

Como vê não tem Portuguese por exemplo, mas tem 9 outros ptXXX

 

Só rodo programas em um computador aqui, e por certo não é no meu PABX. Então de volta do ssh veja esse programa

  

#include <locale.h>
#include <stdio.h>
int main(void)
{
    struct lconv* info_do_local;
    char local[256];
    char* p = local;
    const char*   um[] = {
        "Portuguese",
        "portuguese",
        "utf8",
        "Clube do Hardware",
        "en-us",
        "C"
    };

    int N = sizeof(um) / sizeof(um[0]);
    for (int i = 1; i <= N; i += 1)
    {
        printf("\nLocale %2d/%2d: \"%s\"\n", i,N, um[i-1]);
        p = setlocale(LC_NUMERIC, um[i-1]);
        if (p == NULL)
            printf("    locale não existe\n");
        else
        {
            info_do_local = localeconv();
            printf(
                "    Ponto decimal: '%s', Separador de milhares: "
                "'%s'\n",
                info_do_local->decimal_point,
                info_do_local->thousands_sep);
        }
    }
    

    return 0;
}

 

Que mostra nessa máquina

  


Locale  1/ 6: "Portuguese"
    Ponto decimal: ',', Separador de milhares: '.'

Locale  2/ 6: "portuguese"
    Ponto decimal: ',', Separador de milhares: '.'

Locale  3/ 6: "utf8"
    locale não existe

Locale  4/ 6: "Clube do Hardware"
    locale não existe

Locale  5/ 6: "en-us"
    Ponto decimal: '.', Separador de milhares: ','

Locale  6/ 6: "C"
    Ponto decimal: '.', Separador de milhares: ''

 

"C"    é o locale padrão.

 

De volta ao programa

 

Seu curso adota um livro? Você tem um livro? Recomendo muito ter um livro. E ler o manual.

  

    printf("-------------------------------------------------\n");
    printf("---------------- Exercício nº 4 -----------------\n");
    printf("-------------------------------------------------\n");
    printf("- Digite valores para os elementos da matriz 3x4:\n");

 

Não escreva isso. É claro que vai chamar 4 vezes a mesma função para fazer a mesma coisa. E se não tem qualquer variável ou formato , use puts(). Muito mais rápido e mais esperto. De todo modo prefira

  

    printf("\
-------------------------------------------------\n\
---------------- Exercício nº 4 -----------------\n\
-------------------------------------------------\n\
- Digite valores para os elementos da matriz 3x4:\n"
        );

 

Que é muito mais rápido e fácil de ler e alinhar...

  

    setlocale(LC_ALL, "Portuguese");  // Idioma em português
    fflush(stdin);                    // limpar o buffer do teclado
    system("color 2f");               // coloca cor no sistema

 

Se não vai usar para nada as definições nem chame setlocale() . Todo o propósito disso devia ser avisar ao usuário qual o carácter de ponto decimal para ele usar quando estiver entrando com os dados da matriz.

 

No fundo  o programa poderia ver o que o cara digitou ou testar o ambiente antes de ler, avisando o usuário. Para isso os programas são escritos.

 

Não use fflush() na entrada. Essa função não é para isso, nem sempre funciona  e só indica que o programa não sabe como consumir os dados.

 

Não use system(). Nunca. Para nada. Está programando em C. system() foi escrita em C, o sistema foi escrito em C. Faça o que quer fazer em C, ou não faça nada.

 

Num for declare as variáveis de controle no for.

 

Se definiu constantes use, E prefira sempre usar todas as letras em maiúsculas num define. Porque usou 3 para o tamanho do vetor????

 

TESTE sempre o retorno de scanf(). É muito ingênuo não testar.

 

 

 

 

 

No geral prefira sempre o locale pt_BR se for usar português.  Note  o idioma em minúsculas e o código do país em maiúscula. E underline e não hífen. Esse parece ser o comum do IETF.

 

Como @devair1010 mostrou, NUNCA escreva um programa interativo. Só vai perder tempo. Muito tempo. Use constantes ou funções geradores --- factory functions.

 

Não use acentos em comentários. Comente o que você fez, como fez. Evite comentários óbvios como "declarando funções"

 

Mudar a cor do fundo da tela não muda muito na soluçõa do problema. Mude depois e por certo não usando system().

 

E se mudar algo na máquina ao final do programa VOLTE ao que tinha antes lá. Isso pode deixar pessoas furiosas.  Imagine mudar as cores da tela no computador do chefe do seu chefe para uma cor que ele odeia....

 

Use funções. Se não sabe usar aprenda. É muito simples e torna sua vida mais simples com C.

 

Se o enunciado não exige o uso do teclado leia de um arquivo. É muito, mais muito mais fácil. Afinal você passa a responsabilidade para quem escreveu o editor de texto. E é muito mais fácil para testar. 

 

Repetindo: nunca escreva um programa interativo. nunca leia do teclado. Mesmo que precise, apenas coloque isso no final.

  • Curtir 1
arfneto
 

arfneto

Postado
Postado
20 minutos atrás, Michel De Lima disse:

@devair1010 removi e não deu certo

 

Leu o que eu expliquei sobre esse lance de locale? Não iria mesmo fazer diferença. Entendeu o que eu mostrei no programa sobre o ponto decimal?

  • Curtir 1
arfneto
 

arfneto

Postado
Postado
14 minutos atrás, Michel De Lima disse:

sim, tambem não deu certo.

que significa?

O que também não deu certo?

como está o programa agora?

corrigiu alguma das coisas de que eu falei?

  • Curtir 1
arfneto
 

arfneto

Postado
Postado
agora, Michel De Lima disse:

é porque meu professor usa o DevC++.

 

Esse é o pior IDE dos que eu já vi. E já vi alguns.

 

De todo modo um IDE é irrelevante: apenas vai gerar um programa. Um arquivo. E esse arquivo é o que você vai usar. O tal exe no Windows. 

 

É para isso que se escreve um programa: para rodar o tal programa. Não para ficar olhando o fonte e teclar F9, F5 control-x-alt-algo e gerar o programa toda vez.

 

E aposto que usa o mesmo compilador nos dois casos... Sabe ao menos que compilador usa, a versão dele? as opções de compilação? Repito, o IDE é irrelevante.

 

Poste o código. Acho que entende que o Dev-C++ vai gerar um X.EXE e o Code::Blocks vai gerar um X.EXE. Ao rodar os dois no terminal o que acontece?

 

  • Obrigado 1
Michel De Lima
 

Michel De Lima

Postado
  • Autor
Postado

@arfneto @arfneto 

#include <stdio.h>  // biblioteca de funções de entrada/saída
#define TAML 3      // tamanho da linha da matriz
#define TAMC 4      // tamanho da coluna da matriz
int main()
{
    //variáveis
    float matriz[TAML][TAMC],trans[TAMC][TAML],vetor[3],maior,soma;
    int l,c;

    printf("---------------- Exercício nº 4 -----------------\n");
    printf("- Digite valores para os elementos da matriz 3x4:\n");

    for (l=0; l<TAML; l++)
        for (c=0; c<TAMC; c++)
        {
            printf ("-> Elemento[%d][%d] = ", l, c);
            scanf ("%f", &matriz[l][c]);
        }

    printf("-------------------------------------------------\n");
    printf("-> Matriz gerada:\n");
    for(l = 0; l < TAML; l++)
    {
        for(c = 0; c < TAMC; c++)
        {
            //mostra a matriz gerada
            printf(" %.2f ", matriz[l][c]);
        }
        printf("\n");
    }

    printf("-------------------------------------------------\n");

    printf("-> Maior valor de cada linha:\n");
    //encontrar maior valor de cada linha
    for (l = 0; l < TAML; l++)
    {
        vetor[l] = matriz[TAML][TAMC];
        for (c = 0; c < TAMC; c++)
        {
            if(matriz[l][c] > vetor[l])
            {
                vetor[l] = matriz[l][c];
            }
        }
    }
    for (l=0; l<TAML; l++)
        //mostra o vetor com o maior valor de cada linha
        printf("Linha %d =  %.2f\n", l, vetor[l]);


    printf("-------------------------------------------------\n");

    printf("-> Maior valor da matriz:\n");
    //encontrar maior valor
    maior = matriz[TAML][TAMC];
    for(l=0; l<TAML; l++)
    {
        for(c=0; c<TAMC; c++)
        {
            if(matriz[l][c] > maior)
            {
                maior = matriz[l][c];
            }
        }
    }
    //mostra o maior valor da matriz
    printf(" - Resultado = %.2f\n",maior);

    printf("-------------------------------------------------\n");

    printf("-> A matriz dividida pelo maior valor encontrado:\n");
    maior = matriz[l][c];
    for (l=0; l<TAML; l++)
    {
        for(c=0; c<TAMC; c++)
        {
            if (matriz[l][c]>maior)
                maior = matriz[l][c];
        }
    }
    for (l=0; l<TAML; l++)
    {
        for(c=0; c<TAMC; c++)
            matriz[l][c] = matriz[l][c] / maior;
    }
    for (l=0; l<TAML; l++)
    {
        for(c=0; c<TAMC; c++)
        {
            //mostra a matriz dividida pelo maior encontrado
            printf(" %.2f  ", matriz[l][c]);
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    printf("-> A soma dos elementos da matriz após a divisão:\n");
    soma=0;
    for(l=0; l<TAML; l++)
        for(c=0; c<TAMC; c++)
            soma = soma + matriz[l][c];

    //mostra a soma depois da divisão
    printf(" %.2f  \n", soma);

    printf("-------------------------------------------------\n");

    printf("-> A transposta da matriz depois da divisão:\n");
    for(l = 0; l < TAML; l++)
    {
        for(c = 0; c < TAMC; c++)
        {
            trans[c][l] = matriz[l][c];
        }
    }
    for(l = 0; l < TAMC; l++)
    {
        for(c = 0; c < TAML; c++)
        {
            //mostra a transposta depois da divisão
            printf(" %.2f  ", trans[l][c]);
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    return 0;
}

 

  • Obrigado 1
arfneto
 

arfneto

Postado
Postado
8 minutos atrás, devair1010 disse:

creio que ele não vai brigar com você por usar outro compilador/IDE diferente do que ele usa ,  o Dev C++ é muito antigo e já faz muito tempo que ele não recebe nenhuma atualização .  e usar ele é ter problema

 

Esses IDE são só "capinhas" em torno do compilador. É preciso saber que compilador está usando e se é de fato o mesmo para os dois IDE e saber se as opções de compilação nos dois são as mesmas. IDE não gera programa. Apenas chama o compilador.

 

Atualizar o IDE não indica necessariamente atualizar o compilador. Pode atualizar apenas o editor e os mecanismos do IDE em si. E gerar exatamente os mesmos programas

  • Obrigado 1
Michel De Lima
 

Michel De Lima

Postado
  • Autor
Postado

@arfneto

esta ali em cima
 

20 minutos atrás, Michel De Lima disse:

@arfneto @arfneto 

#include <stdio.h>  // biblioteca de funções de entrada/saída
#define TAML 3      // tamanho da linha da matriz
#define TAMC 4      // tamanho da coluna da matriz
int main()
{
    //variáveis
    float matriz[TAML][TAMC],trans[TAMC][TAML],vetor[3],maior,soma;
    int l,c;

    printf("---------------- Exercício nº 4 -----------------\n");
    printf("- Digite valores para os elementos da matriz 3x4:\n");

    for (l=0; l<TAML; l++)
        for (c=0; c<TAMC; c++)
        {
            printf ("-> Elemento[%d][%d] = ", l, c);
            scanf ("%f", &matriz[l][c]);
        }

    printf("-------------------------------------------------\n");
    printf("-> Matriz gerada:\n");
    for(l = 0; l < TAML; l++)
    {
        for(c = 0; c < TAMC; c++)
        {
            //mostra a matriz gerada
            printf(" %.2f ", matriz[l][c]);
        }
        printf("\n");
    }

    printf("-------------------------------------------------\n");

    printf("-> Maior valor de cada linha:\n");
    //encontrar maior valor de cada linha
    for (l = 0; l < TAML; l++)
    {
        vetor[l] = matriz[TAML][TAMC];
        for (c = 0; c < TAMC; c++)
        {
            if(matriz[l][c] > vetor[l])
            {
                vetor[l] = matriz[l][c];
            }
        }
    }
    for (l=0; l<TAML; l++)
        //mostra o vetor com o maior valor de cada linha
        printf("Linha %d =  %.2f\n", l, vetor[l]);


    printf("-------------------------------------------------\n");

    printf("-> Maior valor da matriz:\n");
    //encontrar maior valor
    maior = matriz[TAML][TAMC];
    for(l=0; l<TAML; l++)
    {
        for(c=0; c<TAMC; c++)
        {
            if(matriz[l][c] > maior)
            {
                maior = matriz[l][c];
            }
        }
    }
    //mostra o maior valor da matriz
    printf(" - Resultado = %.2f\n",maior);

    printf("-------------------------------------------------\n");

    printf("-> A matriz dividida pelo maior valor encontrado:\n");
    maior = matriz[l][c];
    for (l=0; l<TAML; l++)
    {
        for(c=0; c<TAMC; c++)
        {
            if (matriz[l][c]>maior)
                maior = matriz[l][c];
        }
    }
    for (l=0; l<TAML; l++)
    {
        for(c=0; c<TAMC; c++)
            matriz[l][c] = matriz[l][c] / maior;
    }
    for (l=0; l<TAML; l++)
    {
        for(c=0; c<TAMC; c++)
        {
            //mostra a matriz dividida pelo maior encontrado
            printf(" %.2f  ", matriz[l][c]);
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    printf("-> A soma dos elementos da matriz após a divisão:\n");
    soma=0;
    for(l=0; l<TAML; l++)
        for(c=0; c<TAMC; c++)
            soma = soma + matriz[l][c];

    //mostra a soma depois da divisão
    printf(" %.2f  \n", soma);

    printf("-------------------------------------------------\n");

    printf("-> A transposta da matriz depois da divisão:\n");
    for(l = 0; l < TAML; l++)
    {
        for(c = 0; c < TAMC; c++)
        {
            trans[c][l] = matriz[l][c];
        }
    }
    for(l = 0; l < TAMC; l++)
    {
        for(c = 0; c < TAML; c++)
        {
            //mostra a transposta depois da divisão
            printf(" %.2f  ", trans[l][c]);
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    return 0;
}

 

aqui

  • Curtir 1
arfneto
 

arfneto

Postado
Postado
4 minutos atrás, Michel De Lima disse:

esta ali em cima

 

que significa?

 

O programa que postou quase nada mudou em relação ao original.

 

Eis as diferenças

  

1,5c1,3
< #include <locale.h>  //biblioteca de funções para idiomas
< #include <stdio.h>   // biblioteca de funções de entrada/saída
< #include <stdlib.h>  // biblioteca de funções de uso geral
< #define tamL 3       // tamanho da linha da matriz
< #define tamC 4       // tamanho da coluna da matriz
---
> #include <stdio.h>  // biblioteca de funções de entrada/saída
> #define TAML 3      // tamanho da linha da matriz
> #define TAMC 4      // tamanho da coluna da matriz
9c7
<     float matriz[tamL][tamC], trans[tamC][tamL], vetor[3], maior, soma;
---
>     float matriz[TAML][TAMC], trans[TAMC][TAML], vetor[3], maior, soma;
12,16d9
<     setlocale(LC_ALL, "Portuguese");  // Idioma em português
<     fflush(stdin);                    // limpar o buffer do teclado
<     system("color 2f");               // coloca cor no sistema
< 
<     printf("-------------------------------------------------\n");
18d10
<     printf("-------------------------------------------------\n");
21,22c13,14
<     for (l = 0; l < tamL; l++)
<         for (c = 0; c < tamC; c++)
---
>     for (l = 0; l < TAML; l++)
>         for (c = 0; c < TAMC; c++)
30c22
<     for (l = 0; l < tamL; l++)
---
>     for (l = 0; l < TAML; l++)
32c24
<         for (c = 0; c < tamC; c++)
---
>         for (c = 0; c < TAMC; c++)
44c36
<     for (l = 0; l < tamL; l++)
---
>     for (l = 0; l < TAML; l++)
46,47c38,39
<         vetor[l] = matriz[tamL][tamC];
<         for (c = 0; c < tamC; c++)
---
>         vetor[l] = matriz[TAML][TAMC];
>         for (c = 0; c < TAMC; c++)
52c44
<     for (l = 0; l < tamL; l++)
---
>     for (l = 0; l < TAML; l++)
60,61c52,53
<     maior = matriz[tamL][tamC];
<     for (l = 0; l < tamL; l++)
---
>     maior = matriz[TAML][TAMC];
>     for (l = 0; l < TAML; l++)
63c55
<         for (c = 0; c < tamC; c++)
---
>         for (c = 0; c < TAMC; c++)
75c67
<     for (l = 0; l < tamL; l++)
---
>     for (l = 0; l < TAML; l++)
77c69
<         for (c = 0; c < tamC; c++)
---
>         for (c = 0; c < TAMC; c++)
82c74
<     for (l = 0; l < tamL; l++)
---
>     for (l = 0; l < TAML; l++)
84c76
<         for (c = 0; c < tamC; c++) matriz[l][c] = matriz[l][c] / maior;
---
>         for (c = 0; c < TAMC; c++) matriz[l][c] = matriz[l][c] / maior;
86c78
<     for (l = 0; l < tamL; l++)
---
>     for (l = 0; l < TAML; l++)
88c80
<         for (c = 0; c < tamC; c++)
---
>         for (c = 0; c < TAMC; c++)
99,100c91,92
<     for (l = 0; l < tamL; l++)
<         for (c = 0; c < tamC; c++) soma = soma + matriz[l][c];
---
>     for (l = 0; l < TAML; l++)
>         for (c = 0; c < TAMC; c++) soma = soma + matriz[l][c];
108c100
<     for (l = 0; l < tamL; l++)
---
>     for (l = 0; l < TAML; l++)
110c102
<         for (c = 0; c < tamC; c++) { trans[c][l] = matriz[l][c]; }
---
>         for (c = 0; c < TAMC; c++) { trans[c][l] = matriz[l][c]; }
112c104
<     for (l = 0; l < tamC; l++)
---
>     for (l = 0; l < TAMC; l++)
114c106
<         for (c = 0; c < tamL; c++)
---
>         for (c = 0; c < TAML; c++)
123d114
<     system("PAUSE");

 

 

Continua com v'rios dos mesmos problemas.

 

 

Sobre o que perguntei antes

 

  • você testou os dois executáveis? 
  • qual o compilador que está usando?
  • confirmou que é o mesmo para os dois IDE?
  • e as opções de compilação? 
  • comparou pelo menos o tamanho dos arquivos gerados?

 

  • Curtir 1
Michel De Lima
 

Michel De Lima

Postado
  • Autor
Postado

@arfneto Testei tudo, testei no release no dev C ++ e no code blocks........ pesquisei e parece que o dev C++ precisa de uma atualização no compilador, é o problema de atualização mesmo no Dev C++, porque no codeblocks rolou liso, e o código não tem erros.

No codeblocks rodou perfeitamente, é essa porcaria de dev mesmo.

imagem_2021-10-11_205420.png

  • Curtir 1
arfneto
 

arfneto

Postado
Postado
42 minutos atrás, Michel De Lima disse:

o dev C++ precisa de uma atualização no compilador, é o problema de atualização mesmo no Dev C++, porque no codeblocks rolou liso, e o código não tem erros.

No codeblocks rodou perfeitamente, é essa porcaria de dev mesmo.

 

Vou escrever de novo a mesma coisa: entenda que o Dev-C++ não é um compilador. E você provavelmente está usando o mesmo compilador para os dois ambientes. 

 

Se você testou com os dois executáveis, pode dizer se eles tem o mesmo tamanho ou tamanho parecido? Você de fato listou os dois?

 

Se você tem por acaso duas versões de compilador rodando uma com cada IDE, entenda que pode colocar as duas como opção nos dois. Os compiladores são simples opções do IDE.

 

De nada adianta postar a execução de novo. 

 

E entenda que se isso que postou veio do IDE de pouco adianta. Isso não é real. Um programa não vive dentro de um IDE. É só um ambiente de desenvolvimento que inclui um ambiente de teste.

 

E já vi muitos programas que rodam bem no IDE mas não rodam no modo normal. Eu mesmo já escrevi um ou outro que acabou assim.

 

O ambiente do IDE é diferente do ambiente normal de execução, me especial em relação ao uso e inicialização de memória.

 

Sobre o programa

 

Notei que o código novo pouco evoluiu em relação ao primeiro que postou e continua com os mesmos problemas.

  

9c7
<     float matriz[tamL][tamC], trans[tamC][tamL],\
  vetor[3], maior, soma;
---
>     float matriz[TAML][TAMC], trans[TAMC][TAML],\
  vetor[3], maior, soma;

 

Esse é o mais folclórico, junto com aquele printf() que te expliquei.

 

Qual o propósito de manter o '3' lá se tem uma constante definida com o total de linhas? Não sou eu quem vai corrigir seu trabalho, de todo modo.

 

 

Você nunca postou o enunciado.
 

E no programa há um lance de matriz transposta que não tem no que postou. Essa era mais uma razão para ter uma função para mostrar a função.

  • Curtir 1
  • Haha 1

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora
 Compartilhar
Ir à lista de tópicos

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

Mais

×
×
  • Criar novo...

LANÇAMENTO!

eletronica2025-popup.jpg


CLIQUE AQUI E BAIXE AGORA MESMO!