Ansi C

@RafaelaOliv Olá, tudo bem com você? Seja bem-vindo ao fórum CdH! como é possível depois de tantas linhas ainda existirem falhas? Que coisa! MANO. #Uma observação A ficha de contato tem 15 campos se eu não errei na contagem, ok... agora imagine você que um sujeito erra no meu da informação ou simplesmente não tenha os dados. Daí sua opção será continuar com dados falsos e alterar mais tarde! O que faz de alterar uma opção eficaz, quando inserir não é. Melhor que seja alterar também inserir contado se o contado não existir. Já com relação à falha da postagem: me desculpe, eu não faço ideia! [] — Boa Sorte

@Ilanez Santos Olá, tudo bem com você? Eu estou muito bem... Seja bem-vindo ao fórum CdH! Então... — Exceto se alguém (ninguém nesse fórum tem gabarito para tanto) me prove o contrário, insistir com seu nível atual é "dá um salto maior que a perna", a solução ética é inverter a ordem dos estudos! Ou seja, você sabe o teor do exercício agora o momento para estudar apenas aquilo que importa à solução 2021 2022; tem praticamente 2 meses de estudo (tem que renunciar 1 hora diária de compromissos que não pode anteriormente)... para aprender (mais) os fundamentos da linguagem C e seus exercícios nos livros! Certamente essa não é a categoria de ajuda que busca no fórum (de "resolução de exercício"). Entretanto, é o caminho... não mais ético! E sim O ético! []

@João Vitor GO Olá — Supondo que as alternativas são digitadas sequencialmente: *, seria os alunos suas notas. *, o que chamam “item” seriam os valores para as colunas do vetor gabarito. *, assim -- são dois vetores, um de 30 posições e outro de 10 posições (notas finais e gabarito). Após o gabarito, digite as 10 alternativas de cada aluno para calcular sua nota durante a entrada. Logo seriam 30 linhas com 10 itens cada (resposta das questões) Para minimizar use 7 linhas e 2 itens! Talvez resolva com dois ‘Loop’: 1st Para processamento durante a entrada! 2nd Para saída. [] — espero que ajude!

@Lipeco Tudo bem você? Comigo, está tudo bem! Sobre o exercício percebe-se 3 operações () no enunciado e se remover toda a gordura da estrutura de dados tabela de Hash, sobram operações e iterações sobre vetores. — Tudo se resume em saber operar os vetores. Após 24 horas a dúvida persistiu... *, vejo que nomeou um apontador de end (não sei o porquê disso), depois declarou uma iteração (certo), imprimiu o código de hash (certo), e por fim chama a função recursivamente (falhou): aproposito, essa função se quer tem argumento. {C} Escrevi rapidamente uma função semelhante à tua, inclusive a simulação utiliza a mesma lógica do vetor global mais ‘loop’-FOR int observar (void) { for (long unsigned indice = 0; indice < 13UL; ++indice) { Linha_hash *lh = tabela_hash + indice; if (lh->tamanho_vet) { printf ("%2lu->", indice); for (long unsigned e = 0; e < 10UL; ++e) { if ((lh->vet + e)->chave) { printf ("%.3lu:%s\t", (lh->vet + e)->chave, (lh->vet + e)->usuario); } } puts (""); } } return 0; } itera a matriz 'tabela_hash' de 0 até 12 *, pega a linha do índice *, verifica se o vetor tem tamanho diferente de zero *, escreve o índice (código de hash) da matriz *, itera o vetor de recipientes (ou de elementos) de 0 até 9 *, com operador de acesso de membros através de ponteiro (->) acessa o apontador dos recipientes (vet) adiciona (e) para indexar, usa o operador (->) para acessar seu membro 'chave', verifica se tem valor diferente de 0 e escreve: 'chave' como decimal positivo, 'usuario' como “strings”. *, escreve uma nova linha e recomeça. Resultado: [] — espero que ajude!

A primeira parte do exercício: {C} #include"stdio.h" int main (void) { int n_maximo = 5; int fatorial = 1; for (int n = 1; n <= n_maximo; ++n) { fatorial *= n; printf ("%d! %d\n", n, fatorial); } return 0; } SAÍDA [] — espero que ajude!

Boa Noite... entendo! Realmente, pelo enunciado o programa não deve solicitar que o usuário digite os valores para n. Ou seja é para exibir (n, resultado) por linha de 1 a 5. [] -

Tudo isso! E além dessas alternativas existe outra pouca /ou nada discutida, principalmente porque envolve duas variáveis além do ponteiro necessário para alocação dinâmica de memória, sendo a alocação dinâmica o seu pior contra, já que implica na liberação da memória após não ser mais necessária, um serviço extra que incomoda às vezes! Essa função é a GETLINE Observo sendo semelhante, pelo menos no processo de entrada, com a 'fgets' Para um exemplo escrevo um programa que digitada uma lista de números positivos inteiros exibirá respectivamente seus fatoriais. Usarei a função na captura dessa lista (linha) de números (“strings”), após conversão para inteiro no programa calcula-se o fatorial, exibe-se o resultado, aponta para hipoteticamente a próxima “strings” e repete tudo enquanto não falhar a conversão de ‘texto’ para número. {C} #include"stdio.h" #include"stdlib.h" int main (void) { char *nums_como_strings = NULL; long unsigned capacidade = 0; //GETLINE //se voltar como esperado, 'sucesso' tem tamanho (>0) da strings //e 'capacidade' tem o numero em bytes alocados int sucesso = getline (&nums_como_strings, &capacidade, stdin) - 1; if (sucesso < 0) { return EXIT_FAILURE; } unsigned num = 1, fatorial = 1; int proximo = 0; while (sscanf (nums_como_strings, "%u%n", &num, &proximo) == 1) { for (unsigned i = 1; i <= num; ++i) { fatorial*= i; } printf ("%u! %u\n", num, fatorial); nums_como_strings+= proximo; num = 1, fatorial = 1; proximo = 0; } free (nums_como_strings - sucesso); (void) sucesso; return EXIT_SUCCESS; } [SAÍDA] [] — espero que ajude!

@Swalls Isso! Eu continuo 'achar' que a quantidade de números inteiros positivos não deve ser importante e a preocupação é com tamanho do fatorial que pode ultrapassar (“overflow”) a capacidade da variável int, logo pedir de 1 a 5 é a maneira dele garantir os fatoriais do exercício. Exemplo: Se fosse eu, gostaria que escrevesse um programa que digitada uma lista de números inteiros positivos mostrasse os respectivos fatoriais, na esperança que o programador (aluno) perceba que pode passar o limite de um inteiro durante os ('debug') testes. {C} #include"stdio.h" int main (void) { char linha_como_strings [BUFSIZ] = {""}; scanf ("%[^\n]", linha_como_strings); char *nums_como_strings = linha_como_strings; unsigned num = 1, fatorial = 1; int proximo = 0; while (sscanf (nums_como_strings, "%u%n", &num, &proximo) == 1) { for (unsigned i = 1; i <= num; ++i) { fatorial*= i; } printf ("%u! %u\n", num, fatorial); nums_como_strings+= proximo; num = 1, fatorial = 1; proximo = 0; } return 0; } SAÍDA [] — espero que ajude!

Desculpa por nada: pois na minha opinião, o enunciado é escrito para gerar confusão mesmo! Do contrário seria explicito na (rotina de) entrada. Dizer "1 a 5 inteiros" (para mim) insinua muitas coisas... [] — valeu, espero que ajude.

Isso, @Thmpv Enunciado "1 a 5 inteiros" para insinuar que serão de 1 até 5 teste para digitação. Por ouro lado, alguém poderia interpretar sendo para exibir os 5 fatoriais de n = 1 até 5, mas não necessariamente digitar os 5 termos..., ou seja, as entradas são; 1, 2, 3, 4, 5. Nessa caso, um ‘loop’ fornece n sequencialmente (de 1 até 5) sem necessidade da digitação por parte do usuário (que só observa o resultado). Quer mais? Coloque no mesmo 'loop' (de 5 repetições) as rotinas que; captura o inteiro, calcula o fatorial e exibe o resultado! Lembre-se de reiniciar a variável fatorial (= 1) depois que a exibir no ("Resultado"). Enfim, independentemente da interpretação sabemos que calcular o fatorial de (n) é a parte principal do exercício e (na minha opinião) seu programa nesse quesito está correto, @Thmpv. [] — acabei, espero que ajude, valeu!

Isso! Foi dito e eu reforço ser um exercício comum com muitíssimas respostas. (Solução complexa): lembro-me aqui (neste fórum) que um usuário resolveu a pergunta com uma função fatorial (n), a propósito, ele usou programação dinâmica: nada de mais, a função tem capacidade de guarda o último produto e argumento (em variáveis static) para ter uma resposta otimizada ao reduzir a hipótese de repetição (ou dar chance de não recalcular). Para uma resposta complexa? Com certeza. Ou Seja: 1st: ‘loop’ pega valor de n, 2th: ‘loop’ faz o "produto de todos os inteiros positivos menores ou iguais a n" (há repetição de produto) [] — espero que ajude!

Isso (@Midori)! Outra solução usa a instrução else. Entretanto, não é a If-else e sim a for-else! Apenas dessa vez anteciparei o experimento e escreverei eu mesmo a minha sugestão. Advirto que você (@Regis Marcos Correa Junior) exercite a lógica do post acima. — Puxe a else para margem do for que passará a pertencer-lhe (apague a última break). Caso: FALSO input0 = 'Ola Python'#input ('Escreva um texto e tecla ENTER? ') input1 = 'Ola Pithon'#input ('Escreva um texto e tecla ENTER? ') for i in input0: if i not in input1: print ('Nem todos os caracteres da primeira string aparecem na segunda') break else: print ('Todos os caracteres da primeira string aparecem na segunda') SAÍDA (Nem...) Caso: VERDADE input0 = 'Ola Python'#input ('Escreva um texto e tecla ENTER? ') input1 = 'Ola Python'#input ('Escreva um texto e tecla ENTER? ') for i in input0: if i not in input1: print ('Nem todos os caracteres da primeira string aparecem na segunda') break else: print ('Todos os caracteres da primeira string aparecem na segunda') SAÍDA (Todos...) [] — espero que ajude.

@iTzCrazy Boa noite! O programa "pausa" na 'scanf' após leitura da 'fgets', na verdade, aguarda o recebimento de mais informações! Digite um texto (de no máximo 9 caracteres) e tecla ENTER.

Acabei lendo às pressas e não vi uma passagem importante de sua resposta, @Chr15 [!] esta passagem Em tese, só isso não basta! RESUMIDAMENTE, as variáveis na função main são vizinhas e o especificador no formato da 'scanf' ("%d") exige um parâmetro do tipo int * (na arquitetura 32 bits aponta para um início da sequência de 4 ‘bytes’). E os compiladores atuais tem (porém, não perfeita) regras para verificação da sintaxe, logo "os comados" abaixo são uma "falha gramatical" [ALERTA DURANTE COMPILAÇÃO] Ignoraremos e continuamos… com esta versão reduzida do programa de maneira que sobrou só a bendita 'scanf' (ou seja, sem as tais 'printf') #include"stdio.h" #include"stdlib.h" #include"stdbool.h" //Incluindo bibliotecas pre-definidas int main (void) { int Inteiro; float Decimal; char Caractere; bool Booleano; //Definindo variáveis e seus tipos Inteiro = 4; Decimal = 1.4; Caractere = 'C'; Booleano = false; //Definindo valores das variáveis printf("\nO valor da variavel Decimal atualmente = %f!\n", Decimal); //Imprimindo na tela scanf("%d", &Booleano); //Pedindo usuário para inserir novo valor printf("\nO novo valor de A = %d", Inteiro); printf("\nO novo valor de B = %f", Decimal); printf("\nO novo valor de C = %c", Caractere); printf("\nO novo valor de D = %d\n\n", Booleano); //Imprimindo valores após a modificação system("pause"); //Pausando após execução return 0; } [SAÍDA] *O valor zero, abaixo da saída do valor atual na 'Decimal', é a entrada para scanf. Observe a igualdade de B C. [] — espero que ajude.

Isso, a resposta do usuário acima (@Izera XD) é a maneira C de pegar a capacidade (em “bytes”) dos tipos. Então, usarei a sugestão dele e anteciparei o experimento com um programa demostrativo que ilustra a capacidade das variáveis do teu programa e seus respectivos tipos, @Chr15. Ilustração #include"stdio.h" #include"stdlib.h" #include"stdbool.h" //Incluindo bibliotecas pre-definidas int main (void) { int Inteiro; float Decimal; char Caractere; bool Booleano; unsigned long capacidade_Inteiro = sizeof(Inteiro), capacidade_Decimal = sizeof(Decimal), capacidade_Caractere = sizeof(Caractere), capacidade_Booleano = sizeof(Booleano), capacidade_int = sizeof(int), capacidade_float = sizeof(float), capacidade_char = sizeof(char), capacidade_bool = sizeof(bool); puts ("capacidade . . . = bytes"); puts ("VARIAVEIS:"); printf ("%s%lu\n%s%lu\n%s%lu\n%s%lu\n", "capacidade_Inteiro = ", capacidade_Inteiro, "capacidade_Decimal = ", capacidade_Decimal, "capacidade_Caractere = ", capacidade_Caractere, "capacidade_Booleano = ", capacidade_Booleano ); puts ("TIPOS:"); printf ("%s%lu\n%s%lu\n%s%lu\n%s%lu\n", "capacidade_int = ", capacidade_int, "capacidade_float = ", capacidade_float, "capacidade_char = ", capacidade_char, "capacidade_bool = ", capacidade_bool ); system ("pause"); //Pausando após execução return 0; } [SAÍDA] * Há 4s e 1s! Agora que ilustrei o operador, usarei a mesma sugestão também numa versão do exemplo comprobatório da estrutura contígua na definição de variáveis do 'post' anterior. #include"stdio.h" #include"stdlib.h" #include"stdbool.h" int main (void) { int Inteiro; float Decimal; char Caractere; bool Booleano; //Definindo variáveis e seus tipos Inteiro = 4; Decimal = 1.5; Caractere = 'C'; Booleano = 0; //Definindo valores das variáveis *(int *) (&Booleano + (sizeof(bool) + sizeof(char) + sizeof(float))) = 1010111; //Com exceção gravar na 'Inteiro' -- tudo isso equivale a referencia dela >'< printf("\nO novo valor de A = %d", Inteiro); printf("\nO novo valor de B = %f", Decimal); printf("\nO novo valor de C = %c", Caractere); printf("\nO novo valor de D = %d\n\n", Booleano); //Imprimindo valores após a modificação system("pause"); //Pausando após execução return 0; } [SAÍDA] *Comprova (pela 2th vez) que as variáveis são vizinhas! [] — espero que ajude!

Isso! Uma boa porção do mistério foi revelado, só não sei dizer se ficou evidente para todos da mesma maneira que para mim, assim explanarei mais um pouco o que acontece entre Booleano e Caractere. 1# Interpretando está cascata de declarações na forma de um vetor de bytes. Sendo que começa em Booleano e termina em Inteiro, por exemplo, se eu desejo trocar o valor da variável 'Inteiro' posso fazer também por qualquer endereço a partir da 'Booleano'. Veja só: #include"stdio.h" #include"stdlib.h" #include"stdbool.h" int main (void) { int Inteiro; float Decimal; char Caractere; bool Booleano; //Definindo variáveis e seus tipos Inteiro = 4; Decimal = 1.5; Caractere = 'C'; Booleano = 0; //Definindo valores das variáveis *(int *) (&Booleano + 6) = 40; //Com exceção gravar na 'Inteiro' printf("\nO novo valor de A = %d", Inteiro); printf("\nO novo valor de B = %f", Decimal); printf("\nO novo valor de C = %c", Caractere); printf("\nO novo valor de D = %d\n\n", Booleano); //Imprimindo valores após a modificação system("pause"); //Pausando após execução return 0; } [SAÍDA] *Prova a si mesmo que a memória dessas declarações é contígua ao tentar outros valores. É dito que um tipo bool tem 8 bits (1 byte), char tem 8 bits (1 byte), float tem 32 bits (4 bytes) que somados é: 6 bytes, daí o motivo de adicionar 6 ao endereço da 'Booleano' para conduzir até o endereço do 'byte' menos significativo da 'Inteiro' que nos permiti acessa-lo. #2 O especificador na função Insinua que o parâmetro tem um decimal inteiro (ou seja, tipo int (32 bits (4 bytes))), entretanto sabemos ser falso, pois um tipo _Bool (ou bool — sendo seu apelido) tem 1 byte tal qual o tipo char. Então, pergunta-se... a scanf grava em cima de quem, já que bool tem 1 byte, mas 'scanf' precisa de 4 bytes? — DA 'Caractere' e DA 'Decimal' e com isso altera suas estruturas e seus valores. [] — espero que ajude!

Olá @Thmpv Isso, e agora que está resolvido, vou acrescentar um detalhe a discussão só para conscientizar. — A cada ciclo no 'loop' a pow repete a potência do ciclo anterior porque está em sequência (1 ... 10) for (ano = 1; ano <= 10; ano++) { quantia = principal * pow(1.0 + taxa, ano); printf ("%4d %21.2f\n", ano, quantia); } Não significa dizer ser um erro porque não é! Digamos que talvez gaste energia. Ilustração /* Calculando juros compostos */ #include"stdio.h" #include"math.h" int main (void) { int ano; double quantia, principal = 1000.0, taxa = .05; double pow_acumulado = 1; printf ("%4s%21s\n", "Ano", "Saldo na conta"); for (ano = 1; ano <= 10; ano++) { pow_acumulado *= 1.0 + taxa; quantia = principal * pow_acumulado; printf ("%4d%21.2f\n", ano, quantia); quantia = principal * pow (1.0 + taxa, ano); printf ("%4d%21.2f\n", ano, quantia); } return 0; } [Saída] [] — sem pânico!

Tive numa discussão pouco semelhante (mais acalorado) com 5 pessoas de um fórum fechado em Portugal que até a moderação entrou na lista de desleixados, é sério! Revendo postagens antigas, notei que aqui também houve discussões semelhantes (no tempo do AnsiC há ~10 anos e outras recentemente no privado: para piorar... odeio privado), mas diferente de ti, que foste de uma observação divertida, outro foi para ridicularizar/constranger. Eu faço o meu melhor sem cobrar muito de mim Esses que curtem ridicularizar o fazem naturalmente porque todos nós procuramos o destaque. Entendo ser perfeitamente normal quando é um jovem, já para os demais eu não tenho paciência mesmo. [] Off-tópico assim é bem legal.

Isso, fica a gosto, já que o resultado é certamente igual; Por exemplo, São argumentos para fazer o que dizem ser "mais simples", mas ambos são igualmente simples a graduação de simplicidade (que para mim) nem existe é mera questão de gosto. Dizer que uma coisa é mais fácil de ler porque tem 0 ou '/0' ou "" e ridiculamente preferencial. Ridiculamente porque o limite do irrelevante. * "Mais fácil de ler" é tão evasivo quanto "mais simples" porque se trata de uma limitação pessoal. Todas as notações são igualmente fáceis ter isso ou aquilo de mais fácil/simples é excluir um por motivo de preferências É bem mais honesto quando dizem: eu prefiro isso do que aquilo. * Economizar teclas, estamos por Acaso numa crise de teclas * "são maiúsculas então ainda tem que apertar o shift" Preocupação com a Lesão por Reforço Repetitivo — LER é razoável e advirto ser um problema que não se evita na "economias teclas" ou qualquer outra regra esdruxula, se não com bom descanso. Descanso será também útil na produtividade. São observações divertidas SIM, que não faz de ninguém um programador melhor/produtivo. #0 A constante é um inteiro de 4 “bytes”, no caso é também uma sequência de ‘bytes’ e sua estrutura ou configuração na memória do computador também são iguais. Determinante na solução que usa (somente) uma camada de switch e case para aquele "desafio". Nossa odeio quando os meus alunos (os mais "fraquinhos") dizem o mesmo... poque isso é evasiva (sem justificativa) porque é uma limitação pessoal/ gosto pessoal no caso estilo. Sempre digo que estilo é algo que só importa alguém se esse trabalha na sua equipe, pois cada equipe define as configurações de estilo e com isso evita discussões inúteis. Uma união é uma categoria de dado especial disponível em C que permite armazenar diferentes categorias de dados no mesmo local de memória. #include"stdio.h" #include"stdlib.h" int main (void) { union {char Chars[sizeof(int)]; int Int;} estado = {"SP"}; printf ("O resultado e igual: %s\n", estado.Int == ('S'|'P' << 8) ? "SIM" : "não"); (void) estado; return 0; } O conceito de “strings” aqui é mais abstrato que aquele dos antigos e adeptos programadores/experientes em C ensinam... o inteiro do lado oposto da varável é sim uma "strings" porque em sua memória há dois ‘bytes’ não nulos seguindo de outros nulos igual à variável 'estado'. #1 Essa condicional IF inicial não tem sentido porque faz o que a 'default' existe para fazer. Digamos que importa saber que toda switch e case são condicionais que um pouco mais analiticamente pode ter o seguinte aspecto: int indice = 0; if (1 != scanf("%2s", Dual.estado)) indice = 4; if (Dual.numero == SP) { indice = 3; } else if (Dual.numero == MG) { indice = 0; } else if (Dual.numero == RJ) { indice = 2; } else if (Dual.numero == MS) { indice = 1; } else { indice = 4; } printf("%s\n", estados[indice]); A primeira condicional examina o 'return' da 'scanf' de 1 especificador, para quê? Para atribuir último índice de um vetor, cuja utilidade persiste durante a função, mas só é útil em uma ocasião e está logicamente acobertado pelo que se chama "Otherwise" (por outro lado)/último else de uma cascata de IF-ELSE. Melor ficou por último *E aspas mudam de lugar de um teclado para outro. O 0 não, [] — sem comentários... Mas, digo que achar as "" é problema pessoal (de poucos) e se resolve.

@Leucosia Olá tudo bem... Há muitos anos outro usuário escreveu dúvida semelhante, me lembro que ele rejeitou as soluções que usaram mais que uma camada de condicionais, ou seja, tinha que ser somente uma camada switch e case. Foram dadas duas propostas: #A consiste em multiplicar o primeiro padrão por um decimal de modo que define outro composto com o segundo padrão. Uma combinação de produto e soma e.g: C language #include"stdio.h" #include"stdlib.h" int main (void) { printf ("Ola, digite uma das siglas dos estados do Basil [SP MG RJ MS]: "); char estado[4] = { "" }; scanf ("%2s", estado); switch (estado[0]*100 + estado[1]) { case 'S'*100 + 'P': printf ("Sao Paulo - %s\n", estado); break; case 'M'*100 + 'G': printf ("Minas Gerais - %s\n", estado); break; case 'R'*100 + 'J': printf ("Rio Janeiro - %s\n", estado); break; case 'M'*100 + 'S': printf ("Mato Grosso Sul - %s\n", estado); break; default: printf ("Sigla inexistente!\n"); } return 0; } #B consiste em deslocar a sequência de 8 bits do segundo padrão por um inteiro de modo que define outro integrando o primeiro padrão. e.g: C language #include"stdio.h" #include"stdlib.h" int main (void) { printf ("Ola, digite uma das siglas dos estados do Basil [SP MG RJ MS]: "); char estado[4] = { "" }; scanf ("%2s", estado); switch (*(int *) estado) { case 'S'|'P' << 8: printf ("Sao Paulo - %s\n", estado); break; case 'M'|'G' << 8: printf ("Minas Gerais - %s\n", estado); break; case 'R'|'J' << 8: printf ("Rio Janeiro - %s\n", estado); break; case 'M'|'S' << 8: printf ("Mato Grosso Sul - %s\n", estado); break; default: printf ("Sigla inexistente!\n"); } return 0; } — Essa é minha recomendação veja que expressão da cláusula simula 'multi-character constant' (uma “strings”). Sugeri também que se usar uma estrutura union ocultaria o cast na expressão da switch. #include"stdio.h" #include"stdlib.h" int main (void) { printf ("Ola, digite uma das siglas dos estados do Basil [SP MG RJ MS]: "); union { char Chars[sizeof(int)]; int Int; } estado; scanf ("%2s", estado.Chars); switch (estado.Int) { case 'S'|'P' << 8: printf ("Sao Paulo - %s\n", estado.Chars); break; case 'M'|'G' << 8: printf ("Minas Gerais - %s\n", estado.Chars); break; case 'R'|'J' << 8: printf ("Rio Janeiro - %s\n", estado.Chars); break; case 'M'|'S' << 8: printf ("Mato Grosso Sul - %s\n", estado.Chars); break; default: printf ("Sigla inexistente!\n"); } return 0; } [SAÍDA] É possível substituir os operadores por multiplicação e adição, mas lógica binária é, para mim, muita mais elegante. [] — Espero que ajude.

@Thmpv bem-vindo! É isso e eu acredito também que essas mensagens de orientação são desfavoráveis porque são vários empréstimos logo essas mensagens repetidas, a cada cálculo, se torna mais e mais inconveniente. — É Interessante aparecer uma vez junto á explicação do que faz este programa. Ex: Uso o 'return' da 'scanf' de 3 especificadores para determinar falha no fluxo e assim interromper as repetições. E desfaço a "cultura" de orientar a entrada a cada repetição. #include"stdio.h" int main (void) { printf ("Informe CAPITAL TAXA DIAS dos emprestimos para o calculo dos JUROS\n"); double capital, taxa, dias; while (scanf (" %lf%lf%lf", &capital, &taxa, &dias) == 3) { // calcule-exiba o juros } return 0; } [] — espero que ajude.

@IzeraXD Isso! O método do critério divisibilidade de 3 tem também no chamado "prova dos noves", mod (9). O resto da divisão inteira de número decimal maior que 9 por 9 é também o resultado da adição dos dígitos mod (9) desse número. Exemplo Uso “loop” while #include"stdio.h" int main (void) { printf ("NOVE FORA\n\n"); printf ("Digite n. inteiro decimal (>9) e direi o mod (9) dessa variavel: "); int a = 0; scanf (" %d", &a); int b = a; #define mod (9) while (mod <= b) b -= mod; printf ("resposta: %d\n", b); return 0; } Algo que certamente com uso do operador 'modulus' (%) resulta um código 'enxuto' (acima sugerido) tanto para 3 quanto para 2. []

@immoraesz Isole o problema e foca nele..., somente nele! Apenas digamos que todo programa funciona, exceto os testes com as 'printf'... Exemplo — Escrevo outro código, mas dessa vez; excluo as informações/rotinas que antecedem o ninho de IFs com 'printf' onde supos ter um problema. E para fim de teste, forneço o produto/ a informação que teríamos nessa etapa do programa já que omito (TáhOquei!!) nas etapas anteriores. C language /> _ //teste do fragmento de cdh@immoraesz #include"stdio.h" #define N 4 typedef struct { char nome[50]; char local[50]; int valor; } ingresso; int main (void) { ingresso a1 = { "a1","1", 1.0 }, a2 = { "a2","2", 2.0 }, a3 = { "a3","3", 3.0 }, a4 = { "a4","4", 4.0 }; double valor1 = a1.valor; double valor2 = a2.valor; double valor3 = a3.valor; double valor4 = a4.valor; if (valor1 < valor2 && valor3 && valor4) { printf("Mais Barato: %s (R$%d.00)", a1.nome, a1.valor); } else if (valor2 < valor1 && valor3 && valor4) { printf("Mais Barato: %s (R$%d.00)", a2.nome, a2.valor); } else if(valor3 < valor1 && valor2 && valor4) { printf("Mais Barato: %s (R$%d.00)", a3.nome, a3.valor); } else if(valor4 < valor1 && valor2 && valor3) { printf("Mais Barato: %s (R$%d.00)", a4.nome, a4.valor); } if (valor1 > valor2 && valor3 && valor4) { printf("Mais Caro: %s (R$%d.00)", a1.nome, a1.valor); } else if(valor2 > valor1 && valor3 && valor4) { printf("Mais Caro: %s (R$%d.00)", a2.nome, a2.valor); } else if(valor3 > valor1 && valor2 && valor4) { printf("Mais Caro: %s (R$%d.00)", a3.nome, a3.valor); } else if(valor4 > valor1 && valor2 && valor3) { printf("Mais Caro: %s (R$%d.00)", a4.nome, a4.valor); } printf ("\n"); (void) a1; (void) a2; (void) a3; (void) a4; return 0; } [SAÍDA] Para aquela entrada de teste tem essa saída, porém, notou-se ser incorreta, ok? Isso ai! Sendo assim pouco importa as printfs quando há erro lógico nas expressões. Tudo bem, sem pânico, acredito que com a boa revisão de instrução IF e os operadores lógicos, você conseguirá na próxima tentativa. Por último, essa CATARATA de IF é nada elegante, certamente algo que cavalheiros ou damas não fariam, exceto se por obrigação..., se não e o caso, advirto ser necessária uma linha para determinar o maior e outra para menor se optar no uso do operador ternário ou função. [] — espero que ajude!

@IzeraXD isole o problema, observe os alerta na compilação. [C] #include"string.h" #include"stdio.h" int main (void) { char texto4[120] = { "" }; char texto3[120] = { "pokemon" }; // resultado pós-leitura do arquivo. unsigned long p; for (p = 0; p < 3; ++p) { strncpy (texto4[p], texto3[p], 2); printf ("uma letra = %s \n", &texto3[p]); } return 0; } [compilador] strncpy: (argumentos) Origem e Destinos são ponteiros. []

Tem-se acesso fora do limite lógico, está fora de limite mais tem capacidade. Isole o problema, forneça a informação da função. [c] #include"stdio.h" int serie_invertida (int n, int termos[]) { int i; printf("\nOrdem inversa:" "\n{"); for (i = n; i >= 0; i--) printf(" %d", termos[i]); printf("}\n"); return 0; } int main (void) { #define n (8) int termos[50] = {1, 2, 3, [n - 5] = termos[0] + termos [1] + termos [2], [n - 4] = termos[1] + termos [2] + termos [3], [n - 3] = termos[2] + termos [3] + termos [4], [n - 2] = termos[3] + termos [4] + termos [5], [n - 1] = termos[4] + termos [5] + termos [6], [n] = 10000, }; (void) serie_invertida (n, termos); } SAÍDA n (8) é numero de termos e último n - 1 (7) [] Isso ajudou a reparar o código