Karpov1

matriz de numeros inteiros nxn, mas nao sei como ela vai ser

Em um papel há diversos números anotados, todos potência de 2. Uma pessoa apaga de todos os números mais da metade dos dígitos. Assim, por exemplo, restaram números como 65 (era originalmente 65536) ou 104 (originalmente 1048576). Seu programa deverá ler várias instâncias do problema. Cada instância é composta por um inteiro positivo 0 ≤ n ≤ 2000000000, sendo que 0 indica o fim dos dados. Para cada inteiro n seu programa deve achar e imprimir (se existir) o menor inteiro k tal que os primeiros dígitos de 2k coincidem com os dígitos de n (lembrando que mais da metade dos dígitos foram apagados). Se não existir tal k, seu programa deverá dar uma mensagem informando isso. Exemplos: Para n = 65 seu programa deverá imprimir 16 pois 2^16 = 65536. Para n = 10 seu programa deverá imprimir 20 pois 2^20 = 1048576. Note que 2^10 = 1024, mas neste caso não teriam sido apagados mais da metade dos dígitos do número.

Suponha que temos uma matriz num arquivo txt e daí a gente quer fazer um programa que vai ler a matriz desse arquivo e então realizar operaçoes com a matriz. Como eu faço pra ler a matriz? Em C.

Sim, mas nao sei fazer...pode fazer?

Escreva uma função que receba uma string s e um inteiro não negativo i e devolva o (i-1)-ésimo caractere de s, ou seja, o caractere s.

Escreva uma função que receba um caractere c e devolva uma string cujo único caractere é c. Em C

O que há de errado nesse fragmento de codigo? char s[20]; s = "ABC"; printf ("%s\n", s);

Escreva uma função que receba strings x e s e devolve o índice da posição a partir da qual x ocorre em s. Esse programa é em C.

Mas ai ta definido a[0][0] e tal , essas matrizes, nao os vetores!! la ta usando a[0] e a [1] na f2, como assim?

Nesse programa, quando chamam a função f2 no int main, colocam a[0] e a[1] no f2, mas nunca foi definido a[0] e a[1] então como isso foi possivel? a resposta diz que v[0] = 1 e w[0] = 5, como chegaram nessa resposta?

Para representação de números reais usamos a técnica de ponto flutuante, igual ao que vemos em calculadoras científicas. Nessa técnica representamos um número real utilizando dois valores: a mantissa e o expoente. Os dígitos do número real são guardados na mantissa e o expoente registra o valor de uma potência de dez que deve multiplicar a mantissa para que se obtenha o número pretendido. Exemplos: -10,41576 => mantissa: -1041576, expoente: -5 => -1041576E-5 0,000123 => mantissa: 123, expoente: -6 => 123E-6 1230 => mantissa: 123, expoente: 1 => 123E1 Podemos ver acima que dois números distintos podem ter a mesma mantissa. Neste caso, o que varia é o expoente, que determina o local onde irá a vírgula (ou o “ponto” na representação em inglês). Em outras palavras, meu ponto pode variar (ou “flutuar”) dependendo do expoente. Em uma representação de ponto flutuante, utilizamos um determinado número de dígitos para representar a mantissa e um determinado número de dígitos para a representação do expoente. Isso quer dizer que os números em ponto flutuante têm uma precisão finita, ou seja, conseguimos representar apenas alguns dígitos do número. Em um computador moderno, os números são representados com números binários, ou seja, números onde os dígitos são apenas 0 e 1. Em números de ponto flutuante uma palavra de memória (32 ou 64 bits) é dividida em duas partes, em uma delas é armazenada a mantissa e em outra o expoente. No segundo exercício programa vocês deverão implementar a representação de números em ponto flutuante utilizando um número inteiro. 2.2 Representação para o exercícioNúmeros inteiros do tipo int em C tem valor entre -2.147.483.648 e +2.147.483.647. Como, apesar de termos até 10 dígitos, o décimo dígito pode ter apenas os valores 0, 1 ou 2, utilizaremos apenas 9 dígitos para representar um número de ponto flutuante neste EP. Nesse número, utilizaremos os dois dígitos menos significativos para o valor do expoente, o terceiro dígito para o sinal do expoente e os 6 dígitos restantes para a mantissa. Representaremos expoentes positivos com o dígito 0 e negativos com o dígito 1. Assim, se quisermos representar o número -4875E-12 nessa codificação em 9 dígitos, ele ficaria da seguinte forma: Vejamos como ficariam os números que vimos acima nessa representação em ponto flutuante com 9 dígitos (destacada em verde aparece a representação do sinal do expoente): -10,41576 => mantissa: -104157, expoente: -4 => -104157E-4 => -104157104 0,000123 => mantissa: 123, expoente: -6 => 123E-6 => -123106 1230 => mantissa: 123, expoente: 1 => 123E1 => 123001 Note que no primeiro número nós perdemos dígitos devido à precisão de apenas 6 dígitos da mantissa. Neste EP, diremos que um número na representação em ponto flutuante com 9 dígitos está normalizado se ele possui o maior valor possível no expoente sem perder precisão. Ou seja, um número só está normalizado se a sua mantissa não possui zeros à direita OU se o seu expoente é 99. Exemplos: O número 123048 (= 123E48) é a versão normalizada dos números não normalizados 123000045 (= 123000E45), 12300046 (= 12300E46) e 1230047 (= 1230E47). De modo análogo, -123048 é a versão normalizada dos números não normalizados -123000045, -12300046 e -1230047. O número 123142 (= 123E-42) é a versão normalizada dos números não normalizados 123000145 (= 123000E-45), 12300144 (= 12300E-44) e 1230143 (= 1230E-43). De modo análogo, -123142 é a versão normalizada dos números não normalizados -123000145, -12300144 e -1230143. Os números 1230099 (= 1230E99), 12300099 (= 12300E99) e 123000099 (= 123000E99) já estão normalizados. De modo análogo, os números -1230099, -12300099 e -123000099 também já estão normalizados. 3. TarefaNeste exercício-programa, a sua tarefa será escrever um programa na linguagem C que deve funcionar como uma calculadora para números de ponto-flutuante. O seu programa deve: Pedir, como operando 1, um número de ponto flutuante na representação de 9 dígitos descrita na Seção 2.2. Perguntar qual a operação desejada, representada por um número (1: '+', 2: '-', 3: '*', 4: '/', 5: limpar, 6: parar). Executar a operação Caso seja pedida uma operação aritmética, o programa deve pedir um novo número de ponto flutuante (na representação de 9 dígitos) como operando 2 e executar a operação sobre os operandos 1 e 2, imprimindo o número de ponto flutuante resultante na representação de 9 dígitos no formato normalizado. Depois, voltar ao passo 2, desta vez usando o resultado como operando 1. Caso seja pedida a operação de 'limpeza', o programa deve voltar ao passo 1. Caso seja pedida a operação de parada, o programa deve terminar. As mensagens emitidas pelo seu programa devem ser idênticas às mensagens mostradas nos exemplos da Seção 5. Importante: Não devem ser feitas verificações nem outras supostas melhorias no programa. Nos passos 1 e 3.a, é esperado que o usuário digite números inteiros de até 9 dígitos e não entre com valores indevidos (como um texto ou um número real). No passo 2, é esperado que o usuário digite um número inteiro entre 1 e 6. É importante ressaltar que, embora os números resultantes das operações realizadas pelo seu programa devam sempre ser exibidos no formato normalizado, os operandos digitados pelo usuário para as operações podem não estar normalizados. Por exemplo, o usuário pode digitar como operando o número 123000045; mas caso esse seja o valor do resultado de uma operação realizada pelo programa, ele deve ser exibido pelo programa como 123048. Para corrigir o seu EP, vamos supor que o seu programa obedece exatamente o que está especificado neste enunciado. Tudo que fugir da especificação prejudicará a avaliação de seu trabalho. As únicas construções --comandos, funções, etc-- da linguagem C que você poderá usar em seu programa são as ensinadas em aula. 3.1 Tratamento de Exceções Caso uma operação solicitada pelo usuário resulte em um número de ponto flutuante que quando normalizado tem expoente menor que -99, você deve transformar o número em zero (0E0), exibir uma mensagem ao usuário avisando sobre a ocorrência de um transbordamento negativo (ou underflow) no expoente do número e continuar a execução do programa normalmente. Caso uma operação solicitada pelo usuário resulte em um número de ponto flutuante maior que 999999E99, você deve transformar o número em 999999E99, exibir uma mensagem ao usuário avisando sobre a ocorrência de um transbordamento positivo (ou overflow) no expoente do número e continuar a execução do programa normalmente. Caso uma operação solicitada pelo usuário resulte em um número de ponto flutuante menor que -999999E99, você deve transformar o número em -999999E99, exibir uma mensagem ao usuário avisando sobre a ocorrência de um transbordamento positivo (ou overflow) no expoente do número e continuar a execução do programa normalmente. Caso o usuário solicite uma divisão por zero, exiba ao usuário uma mensagem de erro e volte ao passo 2 (para pedir uma nova operação), usando o mesmo operando 1 que seria usado na operação anterior (a divisão que resultou em erro). 4. Orientações para a Implementação 4.1 Sobre a Precisão da MantissaNa especificação do EP é requisitado que vocês utilizem a precisão de 6 dígitos na mantissa. Porém os números inteiros têm 9 dígitos de precisão completa. Utilize esses dígitos extras para lidar com resultados de operações que resultam em mais de 6 dígitos, reduzindo depois aos 6 mais significativos. Assim, nas iterações vocês devem verificar após cada resultado parcial se o número tem mais de 6 dígitos, dividindo a mantissa por 10 e ajustando o expoente no caso positivo (abaixo mostramos casos de ajuste). CUIDADO: seus números podem ser positivos OU negativos. 4.2 Implementação da SomaPara somar dois números em ponto flutuante, você deve primeiro se assegurar de que eles tenham grandezas compatíveis. Para isso, primeiro você pode "denormalizar" o número de maior expoente, decrementando o seu expoente até que ele fique com o mesmo valor do menor expoente ou até que a sua mantissa fique com 6 dígitos (o que acontecer primeiro). Se a mantissa chegar a 6 dígitos antes do expoente ficar igual ao do menor, então será preciso cortar dígitos da mantissa do número de menor expoente, incrementando o seu expoente até que ele fique igual ao valor atual do maior expoente (e isso pode transformar a mantissa do número em zero se ele for muito pequeno em comparação ao outro número). Depois dessas transformações, você pode fazer a soma normalmente. Assim, caso não haja precisão suficiente no sistema para a representação da soma, o programa deverá exibir como resposta o número de maior valor absoluto. Eventualmente, a perda de dígitos pode ser parcial, dependendo da diferença entre os expoentes e da quantidade de dígitos na mantissa de cada número. Exemplo (supondo mantissa com precisão de 6 dígitos): 475E10 + 987E-10 = 475E10 325E8 + 456E3 = 325E8 + 4E3 = 325004E5(Para entender melhor, expanda os números das mantissas com os zeros, faça a conta e veja quais são os dígitos mais significativos). É importante verificar se a soma acarretou em uma mantissa de 7 dígitos. Neste caso, devemos eliminar o último dígito da mantissa e ajustar o expoente: 123456E0 + 9E5 = 1023456E0 = 102345E1 4.3 Implementação da SubtraçãoBasta usar uma transformação no segundo operando para utilizar o mesmo algoritmo que a soma. 4.4 Implementação da MultiplicaçãoVocê deve fazer a operação dígito a dígito na mantissa do operando 2 e ir somando os resultados. CUIDADO: isso não é trivial, você deve ajustar o expoente a cada passo e talvez precise ajustar a precisão, quando a soma do resultados parciais utilizar mais de 6 dígitos, ou seja, a cada passo devemos fazer uma soma de números de ponto flutuante. Assim, se formos multiplicar 222E-8 por 432E-1, iremos calcular a soma aos poucos: Soma = 0E0 Soma = Soma + (222E-8 * 2E-1) => Soma = 0E0 + 444E-9 => Soma = 444E-9 Soma = Soma + (222E-8 * 3E0) => Soma = 444E-9 + 666E-8 => Soma = 7104E-9 Soma = Soma + (222E-8 * 4E1) => Soma = 7104E-9 + 888E-7 => Soma = 95904-9 A cada passo, após fazer o produto, verifique se a mantissa do produto possui mais de 6 dígitos. Se esse for o caso, você deve ajustar o expoente. Como exemplo, vejamos o produto 222222E6 * 516E2: Soma = 0E0 Soma = Soma + (222222E6 * 6E2) => Soma = 0E0 + 1333332E8 => Soma = 0E0 + 133333E9 => Soma = 133333E9 Soma = Soma + (222222E6 * 1E3) => Soma = 133333E9 + 222222E09 => Soma = 355555E9 Soma = Soma + (222222E6 * 5E4) => Soma = 355555E09 + 1111110E10 => Soma = 355555E9 + 111111E11 => Soma = 114666E11 Neste caso, foi preciso fazer um ajuste após o produto (e antes de somar) para diminuir a precisão da mantissa para 6 dígitos nos passos I e III. O resto do problema é a reprodução da soma de dois números de ponto flutuante. No exemplo acima, os números ajustados após o produto estão destacados em vermelho. 4.5 Implementação da DivisãoDe forma semelhante ao produto, você vai precisar "descascar" a divisão e utilizar o algoritmo da soma. Mas agora o procedimento é diferente. Lembre-se, temos apenas a divisão inteira. Assim vamos dividir o número e os restos sucessivos das divisões até termos zero de resto ou utilizarmos toda a precisão. Para isso, a cada passo multiplicamos a mantissa do resto por 10 e decrementamos o expoente de 1. Como exemplo, vejamos a divisão 1E0 / 4E0: Soma = 0E0 Soma = Soma + ((1/4)E0) => Soma = 0E0 + 0E0 => Soma = 0E0 (com resto = 1E0) Soma = Soma + ((10/4)E-1) => Soma = 0E0 + 2E-1 => Soma = 2E-1 (com resto = 2E0) Soma = Soma + ((20/4)E-2) => Soma = 2E-1 + 5E-2 => Soma = 25E-2 (com resto = 0) No caso acima, a divisão dá exata (25E-2) ainda na precisão de nossa aritmética. Mas se isso não acontecer, precisamos parar na precisão máxima, ou seja, quando tivermos 6 dígitos significativos na mantissa. Mais um exemplo, a divisão 1E0 / 6E1: Soma = 0E0 Soma = Soma + ((1/6)E-1) => Soma = 0E0 + 0E-1 => Soma = 0E-1 (com resto = 6E0) Soma = Soma + ((10/6)E-2 => Soma = 0E-1 + 1E-2 => Soma = 1E-2 (com resto = 4E0) Soma = Soma +((40/6)E-3) => Soma = 1E-2 + 6E-3 => Soma = 16E-3 (com resto = 4E0) Soma = Soma +((40/6)E-4) => Soma = 16E-3 + 6E-4 => Soma = 166E-4 (com resto = 4E0) Soma = Soma +((40/6)E-5) => Soma = 166E-4 + 6E-5 => Soma = 1666E-5 (com resto = 4E0) Soma = Soma +((40/6)E-6) => Soma = 1666E-5 + 6E-6 => Soma = 16666E-6 (com resto = 4E0) Soma = Soma +((40/6)E-7) => Soma = 16666E-6 + 6E-7 => Soma = 166666E-7 (com resto = 4E0) No exemplo acima, temos uma divisão cujo o resultado é uma dízima. O resultado dessa divisão com a precisão máxima de 6 dígitos para a mantissa é 166666E-7. 4.6 Casos que Requerem Cuidados Especiais Valores zero no expoente e na mantissa: mantissas zero com expoentes diferentes de zero podem acarretar problemas se vocês não estiverem atentos. Números negativos: as operações de divisão inteira ('/') e resto de divisão inteira ('%') envolvendo um número inteiro negativo fornecem como resultado um número inteiro negativo também. Isso pode causar erros na extração do expoente e do sinal se vocês não tiverem cuidado. 5. Exemplos de Execução Nos exemplos, considere que tudo que aparece em vermelho foi digitado pelo usuário. Exemplo 1Uma sequência envolvendo todos os tipos de operações: MAC2166 - EP2 - Calculadora para Numeros de Ponto Flutuante Operando 1...................: 325001 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 1 Operando 2...................: 2638104 Resultado (e novo operando 1): 325026102 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 3 Operando 2...................: 852103 Resultado (e novo operando 1): 276921102 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 2 Operando 2...................: 456908101 Resultado (e novo operando 1): -429216101 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 4 Operando 2...................: 72004 Resultado (e novo operando 1): -596133107 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 5 Operando 1...................: 222222006 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 3 Operando 2...................: -516002 Resultado (e novo operando 1): -114666011 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 6 Tchau! Exemplo 2Uma sequência de operações que resulta em underflow de expoente: MAC2166 - EP2 - Calculadora para Numeros de Ponto Flutuante Operando 1...................: 43210196 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 4 Operando 2...................: 1004 Resultado (e novo operando 1): 4321199 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 4 Operando 2...................: 10000 *** AVISO: ocorreu um underflow no expoente. *** Resultado (e novo operando 1): 0 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 2 Operando 2...................: -34517156 Resultado (e novo operando 1): 34517156 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 6 Tchau! Note que o Exemplo 2 também ilustra a possibilidade do usuário fornecer operandos em formatos não normalizados: 43210196 (43210E-96) e 10000 (10E0). Exemplo 3Uma sequência de operações que resulta em overflows de expoente: MAC2166 - EP2 - Calculadora para Numeros de Ponto Flutuante Operando 1...................: 999478099 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 1 Operando 2...................: 80000097 *** AVISO: ocorreu um overflow no expoente. *** Resultado (e novo operando 1): 999999099 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 3 Operando 2...................: -1000 Resultado (e novo operando 1): -999999099 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 4 Operando 2...................: 2000 Resultado (e novo operando 1): -499999099 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 1 Operando 2...................: -600000099 *** AVISO: ocorreu um overflow no expoente. *** Resultado (e novo operando 1): -999999099 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 6 Tchau! Exemplo 4Uma sequência de operações envolvendo uma divisão por zero: MAC2166 - EP2 - Calculadora para Numeros de Ponto Flutuante Operando 1...................: 1234102 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 4 Operando 2...................: 0 *** ERRO: nao e' possivel dividir por zero. *** Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 4 Operando 2...................: 2105 Resultado (e novo operando 1): 617003 Operacoes disponiveis: 1 (+), 2 (-), 3 (*), 4 (/), 5 (limpar), 6 (parar) Numero da operacao desejada..: 6 Tchau!

Uma outra duvida...na solução que usa "for" dessa questão..eu troquei a linha "if (possivel == NAO)" por "else if (possivel == NAO)" Mas quando eu ponho esse "else" antes o programa dá como saida "nao é possivel descontar o cheque" umas 2 vezes e daí sim dá os resultados das trocas , por exemplo, quando eu uso notas de 5 e 10 e cheque de 20 reais aparece isso que falei... Por que está dando problema quando eu ponho else antes desse if?

Eu pensava que dava na mesma por for e while, mas tem programas aqui que quando eu substituo o for por while dá erro..por exemplo, nesse programa dado um valor em cheque de c reais e notas de a e b reais, você tinha que saber se daria pra fazer a troca...ou seja a+b =c. Fica assim as duas resoluçoes com while e for: #include <stdio.h> #define SIM 1 #define NAO 0 int main() { int a, b; /* valores das notas */ int c; /* valor do cheque */ int na; /* numero de notas de a reais */ int nb; /* numero de notas de b reais */ int possivel; /* indica e foi possivel descontar o cheque */ printf("Digite os valores das notas: "); scanf("%d %d", &a, &; printf("Digite o valor do cheque: "); scanf("%d", &c); possivel = NAO; for (na = 0; na <= c/a; na++) { for (nb = 0; nb <= c/b; nb++) { if (na*a + nb*b == c) { printf("%d nota(s) de %d e %d nota(s) de %d\n",na,a,nb,; possivel = SIM; } } } if (possivel == NAO) { printf("Nao é possivel descontar o cheque\n"); } return 0; } E solução com while: #include <stdio.h> #define SIM 1 #define NAO 0 int main() { int a, b; /* valores das notas */ int c; /* valor do cheque */ int na; /* numero de notas de a reais */ int nb; /* numero de notas de b reais */ int possivel; /* indica e foi possivel descontar o cheque */ printf("Digite os valores das notas: "); scanf("%d %d", &a, &; printf("Digite o valor do cheque: "); scanf("%d", &c); possivel = NAO; na = 0; while (na <= c/a) { nb = 0; while (nb <= c/b) { if (na*a + nb*b == c) { printf("%d nota(s) de %d e %d nota(s) de %d\n",na,a,nb,; possivel = SIM; } nb = nb + 1; } na = na + 1; } if (possivel == NAO) { printf("Nao é possivel descontar o cheque\n"); } return 0; } Por que ha essa diferença de ordem das variaveis? E o que é esse DEFINE SIM e DEFINE NAO no começo? poderia retirar isso?

Isrnick, eu tentei fazer o programa seguindo o raciocinio que você montou nessa tabela, mas tá dando errado...fiz assim: #include <stdio.h> #include <stdlib.h> int main(){ int n, e, resto; printf("n: "); scanf("%d", &n); printf("e: "); scanf("%d", &e); if(!e){ printf("%d\n", n); exit(0); } else { printf ("n/(10^e)) "); printf(","); resto = n % (10^e); } while(e--){ printf("resto/(10^e)"); resto = resto % (10^e); } return 0; } Pode corrigir o que está errado?

Eu entendi o programa que ele escreveu até antes do primeiro while, depois eu nao entendi...Vamos por partes: while(e--){ decimal += (n % 10) * d; d *= 10; O que ele quis dizer com essas duas frases? if(!(n % 10)) zeros++; else zeros = 0; n /= 10; } Aqui ele quis dizer que se o resto de n por 10 for diferente de zero, a gente vai acrescentar um zero no numero, senão a gente nao vai acrescentar zeros e vamos substituir n pelo quociente de n por 10? if(!decimal) zeros--; printf("%d.", n); while(zeros--) printf("0"); printf("%d\n", decimal); Aqui eu nao entendi nada.... return 0; }

Eu tenho uma duvida "while(e--){" que você escreveu...isso significa que enquanto e = e -1 algo vai acontecer. então, por exemplo, se o expoente for 5, você vai substituir o 5 por 4 e fazer algo, dai você vai substituir o 4 por 3 e fazer outra coisa, dai vai indo...nunca vai acabar esse while...nao entendi ....

Eu fui falar com meu professor, ele disse que nao pode usar a função float porque ele nao ensinou ainda....desculpa pedir, mas vocês poderiam fazer sem o float?

Alguém dá um help aqui hehe

Sim, é importante ficar igual no exemplo.... E você testou n = 543210 e=3 e deu 543.210022? no ultimo problema q você fez deu isso quando eu testei...

Hmm..tem algo errado..tipo..quando eu ponho n = 543210 e e=1 fica 54321.000000 e quando eu ponho n = 543210 e e= 0 fica 543210.000000. Teve esses zeros a mais no final que nao pode ter...Esse erro teve tanto com pow e no novo programa que você fez agora. , Agora, nessa nova função que você fez, outro problema surgiu..quando eu ponho n = 543210 e=3 fica 543.210022 O que está errado?

Função pow nao pode...nao aprendi ainda..se você puder dar uma alterada tirando o pow ficarei muito grato

Eu sei que scanf serve pra você registrar os valores das variaveis e int pra declarar variaveis...mas honestamente eu nao entendi bem as aulas e procurei na net mas nao achei videos legais e tal...daí eu queria que alguem resolvesse esse ep pra mim e eu iria estudar a partir desse exercicio resolvido...tem problema pra você fazer o problema inteiro?

Eu não sei fazer esse programa, você pode fazer ele e postar aqui?

Neste EP, trabalharemos apenas com a representação de numeros reais positivos. E, para isso, vamos usar a notação em ponto flutuante de um modo simplificado. Nesse modo, um número real positivo será representado por dois números inteiros positivos "m" e "e" tais que: n = m.10^-e Exemplos: Se, m = 275 e=4 então n = 0,0275 Observe que, nessa representação, m consiste nos algarismos significativos do número, enquanto e indica a posição da vírgula (= posição do separador de casas decimais) do número na notação decimal. 3. Tarefa Neste exercício-programa, a sua tarefa será escrever um programa na linguagem C que leia um número real positivo representado na notação descrita na anteriormente e depois exiba o número correspondente na notação decimal. O seu programa deve: ler um número inteiro m, sendo m>=0 (indicando os algarismos significativos do número decimal) ler um número inteiro e, sendo e>=0 (indicando a posição da vírgula no número decimal) mostrar na tela o valor de m.10^-e em notação decimal Note que você deve usar a vírgula como separador de casas decimais no número exibido pelo seu programa. O seu programa deverá finalizar depois de executar uma e somente uma vez os passos de 1 a 3. As mensagens emitidas pelo seu programa devem ser idênticas às mensagens mostradas nos exemplos da seção seguinte. Importante: Não devem ser feitas verificações nem outras supostas melhorias no programa. É esperado que o usuário digite inteiros positivos correspondentes a "m" e "e" e não entre com valores indevidos (como um texto, um número real ou um inteiro negativo). Para corrigir o seu EP, vamos supor que o seu programa obedece exatamente o que está especificado neste enunciado. Tudo que fugir da especificação prejudicará a avaliação de seu trabalho. As únicas construções --comandos, funções, etc-- da linguagem C que você poderá usar em seu programa são as mais simples, porque eu só tive 3 aulas de computação até agora. 4. Exemplos de Execução Nos exemplos, considere que tudo que aparece em vermelho foi digitado pelo usuário. Exemplo 1 Posição do separador de casas decimais é maior do que o número de algarismos: MAC2166 - EP1 - Usando Inteiros para Representar Reais Digite os algarismos do numero..................: 543210 Digite a posicao do separador das casas decimais: 8 O numero correspondente na notacao decimal e....: 0,00543210 Exemplo 2 Posição do separador de casas decimais é menor do que o número de algarismos: MAC2166 - EP1 - Usando Inteiros para Representar Reais Digite os algarismos do numero..................: 543210 Digite a posicao do separador das casas decimais: 3 O numero correspondente na notacao decimal e....: 543,210 Exemplo 3 Mais um caso em que a posição do separador de casas decimais é menor do que o número de algarismos: MAC2166 - EP1 - Usando Inteiros para Representar Reais Digite os algarismos do numero..................: 543210 Digite a posicao do separador das casas decimais: 1 O numero correspondente na notacao decimal e....: 54321,0 Exemplo 4 Um número sem casas decimais (ou seja, a posição do separador de casas decimais é zero): MAC2166 - EP1 - Usando Inteiros para Representar Reais Digite os algarismos do numero..................: 543210 Digite a posicao do separador das casas decimais: 0 O numero correspondente na notacao decimal e....: 543210