britivaldo

Declara ela depois que capturar as dimensões, #include <stdio.h> #include <stdlib.h> #include <locale.h> int main(void) { setlocale(LC_ALL, ""); int tamanho1, tamanho2, l, c; //int matriz3[tamanho1][tamanho2]; //Pegando o tamanho da matriz! printf("\nQual o tamanho da matriz?\n"); scanf("%d", &tamanho1); scanf("%d", &tamanho2); int matriz3[tamanho1][tamanho2]; //Pegando os valores para a matriz! for(l = 0; l < tamanho1; l++){ for(c = 0; c < tamanho2; c++){ printf("\nDigite um valor para o índice [%d][%d]: ", l, c); scanf("%d", &matriz3[l][c]); } } system("pause"); return 0; } Outra maneira relaciona a função malloc, de stdlib.h, e ponteiros [assunto importantíssimo] para alocação dinâmica, também em tempo de execução. //Pegando o tamanho da matriz! printf("\nQual o tamanho da matriz?\n"); scanf("%d", &tamanho1); scanf("%d", &tamanho2); int (*matriz3)[tamanho2]= malloc(tamanho1 * sizeof(matriz3[0])); Ponteiros é um assunto fácil de compreender com concentração e cuidado.

Não é um programa, é um exercício de autoavaliação de aprendizagem. Não faz sentido simplesmente resolver/ou ajudar a resolver porque é individual.

Defina um vetor de 80 elementos e preencha com valores de 1 a 80, embaralhe os números e sorteio as posições, randomicamente, usando qualquer algoritmo de baralhamento. Os recursos são bem óbvios: função rand, loop, vetores e struct

Comece definindo a variável temperatura e em seguida, os comandos de decisão com bloco de código de IF ELSE. Cada mensagem é um IF. Os operadores condicionais são necessários para definir a expressão de intervalos. Geralmente, para um iniciante, não representa desafio algum esse nível de exercício. Faça uma tentativa, post e escreva sua dúvida

A impressão é que está mais complicado do que precisa ser uma lista estática sequencial — L.E.S. Outra coisa, contextualizar o exemplo com menu, depois que construir a lista. Um exemplo de estrutura de dados é o tipo int, ela possui métodos que permite realizar operação aritmética. Então, as funções de sua L.E.S, sãos as operações. A primeira operação é DEFINIR: "Cria-se", ou basicamente, aloca-se um vetor de tipo. No caso, vamos escolher a estrutura int. #include <stdlib.h> void * lista_definir(unsigned capacidade) { int *p= malloc((capacidade * sizeof(int)) + (2 * sizeof(int))); if (p == NULL) { perror("Memoria Livre Insuficiente."); return p; } *(0 + p)= capacidade; *(1 + p)= 0; //Tamanho é o números de elementos inseridos. return p; } Na primeira linha, aloca-se dinamicamente a capacidade da lista, mais dos itens que guardam informações da lista, sendo sua capacidade e tamanho, respectivamente, o primeiro e segundo inteiros na sequência. Com valores atribuídos próximo do retorno da função. /*******************************************************************************/ #include <stdio.h> #include <stdlib.h> void * lista_definir(unsigned capacidade) { int *p= malloc((capacidade * sizeof(int)) + (2 * sizeof(int))); if (p == NULL) { perror("Memoria Livre Insuficiente."); return p; } *(0 + p)= capacidade; *(1 + p)= 0; //Tamanho é o números de elementos inseridos. return p; } int main(void) { void *numero_de_habitantes= lista_definir(10); free(numero_de_habitantes); return 0; } Compreende? A seguir, tente as funções que entregam o tamanho, e a capacidade da lista, use o que já conhece de ponteiros. [🙂]

Float é um tipo menos preciso que double e o número de casa decimais foi arredondado para caber na saída padrão. Na norma EUA, o separador de frações é ponto (.). escreva std::fixed para desligar o arredondar.

Siga mais o que diz o "enunciado", a receita diz que a função 'recebe'; isso significa que a função possui argumentos específicos, no caso para uma dada matriz 10x5 #include <stdio.h> void entrada(unsigned nLINHA, unsigned nCOLUNA, float matriz[][nCOLUNA]) { float numero= 0; printf("%s%u%s", "Entre com seguimento de ", nLINHA * nCOLUNA, " numeros: "); for (unsigned l= 0; l < nLINHA; ++l) { for (unsigned c= 0; c < nCOLUNA; ++c) { numero= 0; scanf(" %f", &numero), matriz[l][c]= numero; } } return; } int main(void) { float tabela[5][1]; entrada(5, 1, tabela); return 0; } Observe a função entrada com 3 argumentos: numero de linhas e colunas da matriz, e a matriz. Dentro, a função itera através de duas estruturas de loop aninhadas para gravar os números digitados pelo usuário. A função lê primeiro por meio da scanf, depois atribui o valor lido a célula (elemento[l, c]) atual na matriz. *A função SOMA deve ter os mesmos argumentos e itera segundo o exercício em apenas a partir de x das linhas da matriz. #include <stdio.h> void entrada(unsigned nLINHA, unsigned nCOLUNA, float matriz[][nCOLUNA]) { float numero= 0; printf("%s%u%s", "Entre com seguimento de ", nLINHA * nCOLUNA, " numeros: "); for (unsigned l= 0; l < nLINHA; ++l) { for (unsigned c= 0; c < nCOLUNA; ++c) { numero= 0; scanf(" %f", &numero), matriz[l][c]= numero; } } return; } float adicao(unsigned nLINHA, unsigned nCOLUNA, float matriz[][nCOLUNA], unsigned xLinha) { float soma= 0; for (unsigned l= xLinha - 1; l < nLINHA; ++l) { for (unsigned c= 0; c < nCOLUNA; ++c) { soma= matriz[l][c] + soma; } } return soma; } int main(void) { float tabela[5][1]; entrada(5, 1, tabela); float soma= adicao(5, 1, tabela, 5); printf("%s%f\n", "SOMA(a partir da linha 5): ", soma); return 0; } A diferença nos argumentos entre entrada e soma é o parâmetro xLinha; que indica o início do somatório.

Existem muitíssimas coisas a melhorar, mas focando apenas na dúvida: analise o que acontece quando responde: N para finalizar o loop [while]. Para isso coloque uma printf depois da scanf com a variável var.

A função decidirá se o argumento é um número inteiro positivo [n. natural] se não retorna -1, depois divida sucessivamente da maior até a menor dezena. As operações são: modulas [%] e divisão [/]. Tente ou desista da matéria, o importante é não enganar a si mesmo

Responda às perguntas: ENTRADA? PROCESSO? SAÍDA? Identifique cada etapa da programação, use o que tem e responda. Por exemplo. Qual a entrada? Um número maior que 1. #include <stdio.h> unsigned entrada(void) { printf("%s", "Entre com numero maior que 1: "); unsigned num= 0; scanf(" %i", &num); return num; } int main(void){ unsigned numero= entrada(); printf("%s %d\n", "você digitou", numero); return 0; } Agora com a entrada, você programa outra função que percorra todos os valores de 2 até a entrada [ou numero] e uma última que é o teste de primalidade: processo e saída #include <stdio.h> unsigned eprimo(unsigned i) { //Escreva o teste aqui return 1; } void processo_saida(unsigned entrada) { for (unsigned i= 2; i <= entrada; ++i) if (eprimo(i)) printf(" %d", i); } unsigned entrada(void) { printf("%s", "Entre com numero maior que 1: "); unsigned num= 0; scanf(" %i", &num); return num; } int main(void){ unsigned numero= entrada(); processo_saida(numero); return 0; } Programa 65% pronto 🙂

Usualmente, precisa de um laço (FOR) que itere a soma de 9 termos a partir de uma valor x. Dessa maneira gerará os valores nas colunas de cada linha seguido ao primeiro valor (Y:). O primeiro valor (Y:), ao que parece, é a soma do valor posicional da linha + 9. O valor posicional é aquele que usamos em notação de matrizes, por exemplo: a31 é o elemento na terceira linha, primeira coluna: 12, como cada linha tem 9 elemento, após o primeiro, conclui-se por tanto que o último elem. é penúltimo + 1, ou 21.

Você demostrou ter alguns dos saberes necessários. Mas, os passos depreendidos no enunciado; esses você, na minha opinião, não entendeu. Subtende-se que os passos são: ENTRADA: 10x números [reais] PROCESSO: média dos 5 primeiros e últimos números. SAÍDA: as médias Logo, a cada 5 números o programa mostra sua média. Observei que seu programa MOSTRA [isto é um erro também] mensagens além das médias. Outra coisa, se usa função, então comece a pensar e resolver exercícios como funções também, por exemplo: defina uma função que permita calcular sua média aritmética ao ler x números e mostrar na tela. Quando definida, chame-a duas vezes. media(5), media(5); É o mesmo exercício 🙂, apague e comece; só para saber... a função terá algo entorno de 5 linhas.

Olá! O algoritmo é uma sequência de produtos. Sendo possível através de PG. [Progressão Geométrica], mas como interessa cada termo na progressão para determinar sua parcela, ao invés de usar equação de PG, use um laço [instrução FOR] dobrando o reajuste a cada repetição. Se entendi, então o acréscimo nas 4 primeiras parcelas são: 0%, 2%, 4% e 8% de reajuste. Evidentemente, trata-se de uma exercício escolar e a primeira tentativa deve ser sua, então mostre-nos o que tem feito até momento.

Boa Tarde, não compreendo o exemplo. Eu desconheço regra que converta caractere 'Y' ou 'X' para número decimal/hexadecimal. É preciso imaginar uma regra de conversão? Não tem mistério, no máximo precisa de dois vetores que são as bases da tradução; no primeiro o caractere e, no outro associado, o seu valor. A associação acontece via índices do vetor.

Compreendes as partes do enunciado do exercício? A mensagem está certa, pois o ano de fabricação é a informação necessária para determinar o desconto. Para o desconto é preciso gravar o valor digitado numa variável ano_fabricacao_do_veículo, ou somente ano (do tipo int) que depois é comparada as constantes que representam os anos de 2000 a 2020, mais precisamente, os 4 intervalos do enunciado (12%, 8%, 6% ou 4%) sendo o desconto para ano. O desconto é outra variável (do tipo flutuante), para escolher o seu valor é preciso escrever as instruções relacionais que decidem num bloco de decisão condicional IF-ELSE a qual intervalo pertence o ano. Porém, o que faz é gravar na variável do tipo flutuante precod, que aproposito seu nome não faz sentido. Se compreende do enunciado que em seguida a leitura do ano de fabricação do veículo determina-se desconto para o preço. Essa parte não existe no enunciado, problema não precisa do nome do convênio. A pergunta correta é: "Tem convenio (1 para SIM ou 0 para não)? " Não adianta continuar se o começo está equivocado.

São todos os números divisíveis (inteiros) simultaneamente por 2 e 3 e 5. Suponha que extremos são 1, 500 e dado x maior que 1 e x menor que 500 os restos da divisão de x por 2 e 3 e 5 são iguais a 0. Para exemplificar analise o primeiro número que satisfaz essa condição, o número 30: 30/2 mod 0 30/3 mod 0 30/5 mod 0 2*3*5 = 30 30 é menor múltiplo comum de 2, 3 e 5. Conclui-se que nenhum valor positivo menor que 30 satisfaz essa segunda parte do exércicio. Isso foi apenas pra perceber um pouco da porção matemática do problema e não é necessário codificação desse fato. O bastante é verificar se o x atual é divisível inteiro simultâneo pelos três fatores, e para verificar e necessário um expressão condicional conjuntiva (&&) das 3 operações. [:)]

Precisa estudar vetores , loops e estrutura condicional.

Precisa de vetores para guardar as informações úteis ao relatório.

São operações comuns sobre vetores, e com relação dúvida... É preciso estudar os vetores e matrizes , funções de entrada e saída que inicialmente as relacionadas ao console / terminal.

Suas condições If deveriam representar o intervalo fechado dos valores. ex. [a ,...,x,..., b] equivalente à a <= x && x <= b Desculpa se isso não ajudar tanto , esse foi o primeiro erro lógico que percebi , faça as devidas correções e questione se precisar de mais ajuda.

Se é exercício escolar coloque também o enunciado completo.

Receba, você entendeu? Trata-se de uma função (que não é a int main). #include <stdio.h> void problema ( int , int , char[] ); int main( void ){ int x = 7 , y = 5; problema(x , y , "Ola" ); return 0; } void problema( int x , int y , char palavra[] ){ int produto = x * y; // Verificar se produto é divisível inteiros por 2, 5 ou 6 // Se sim então imprimir a palavra 10'000 com loop // Senão imprimir 4527 com loop } É preciso usar loop para repetir tantas vezes o mesmo comando.

Não entendi! Entretanto, os diferentes tipos de estrutura de dados tem operações que diferentes entre elas, essa regrinha é tudo que nos permite identificar uma fila, uma pilha, e uma lista. Uma pilha que também é uma fila é, por conta, uma lista. A únicas operações comuns de lista permitida a pilhas e filas é: listar e riscar (no fim). Nas Pilhas struct LISTA *minha_pilha = NULL; listar( &minha_pilha , 10 , FIM ); // equivalente à empilhar( x ) listar( &minha_pilha , 11 , FIM ); // listar( &minha_pilha , 12 , FIM ); // int numero = 0; riscar( &minha_pilha , &numero , FIM ); // equivalente à desempilhar( x ) O resultado é numero com : 12, e a Pilha com : { 10 , 11 }. Se desempilhar em seguida terá 11 e { 10 }, respectivamente. Entendeu?

Entendi... Basicamente precisa calcular a diferença de tempos inicial, final e para fazer essa operação precisará da biblioteca time.h padrão mais uma cláusula IF ou loop While, qualquer instrução com decisão condicional que permita avaliar a diferença por segundo.

Após o VOTO o fluxo seria desviado para o menu. É isso que não acontece se chamar a int main porque tecnicamente empilha versões novas dela com novas variáveis que não tem os dados das anteriores. É preciso implementar um loop: for, do, while ou até goto. Para retomar o menu depois do VOTO.