isrnick

Aqui, eu fiz uma resolução (não fiz muitos testes então ainda pode ter algum problema): #include <stdio.h>#include <stdlib.h>void separamantissaeexpoente(int n, int *mantissa, int *expoente){ *expoente = abs(n) % 100; n /= 100; if (abs(n) % 10 == 1) *expoente *= -1; *mantissa = n / 10;}int combinamantissaeexpoente(int mantissa, int expoente){ int num, contdigitos = 0; if (mantissa != 0){ while (abs(mantissa) % 10 == 0) { mantissa /= 10; expoente++; } for (num = mantissa; num != 0; num /= 10) contdigitos++; while (contdigitos > 6) { mantissa /= 10; expoente++; contdigitos--; } } else expoente = 0; if (abs(expoente) <= 99){ if (expoente >= 0){ if (mantissa >= 0) return ((mantissa * 1000) + expoente); else return ((mantissa * 1000) - expoente); } else { if (mantissa >= 0) return ((mantissa * 1000) + 100 + abs(expoente)); else return ((mantissa * 1000) - 100 - abs(expoente)); } } else return 1200;}void igualaexpoentes (int *mantissa1, int *expoente1, int *mantissa2, int *expoente2){ int num, contdigitos = 0; if(*expoente1 != *expoente2) { if(*expoente1 > *expoente2) { for (num = *mantissa1; num != 0; num /= 10) contdigitos++; while (contdigitos < 6 && *expoente1 > *expoente2) { *mantissa1 *= 10; *expoente1 -= 1; contdigitos++; } while (*expoente1 > *expoente2) { *mantissa2 /= 10; *expoente2 += 1; } } else { for (num = *mantissa2; num != 0; num /= 10) contdigitos++; while (contdigitos < 6 && *expoente1 < *expoente2) { *mantissa2 *= 10; *expoente2 -= 1; contdigitos++; } while (*expoente1 < *expoente2) { *mantissa1 /= 10; *expoente1 += 1; } } }}int soma(int n1, int n2){ int mantissa1, expoente1, mantissa2, expoente2, mantissa3, expoente3; separamantissaeexpoente(n1, &mantissa1, &expoente1); separamantissaeexpoente(n2, &mantissa2, &expoente2); igualaexpoentes (&mantissa1, &expoente1, &mantissa2, &expoente2); mantissa3 = mantissa1 + mantissa2; expoente3 = expoente1; return combinamantissaeexpoente(mantissa3, expoente3);}int main() { int n1, n2; printf("Digite o primeiro número: "); scanf("%d", &n1); printf("Digite o segundo número: "); scanf("%d", &n2); printf("Soma: %d\n", soma(n1, n2)); return 0;} O que fiz foi sempre expandir o número que tem o maior expoente até ele ter 6 dígitos (e decrementa o expoente pra compensar) ou até seu expoente se igualar ao expoente menor, se chegar aos 6 dígitos e os expoentes ainda não forem iguais ele começa a incrementar o expoente menor (e excluir dígitos menos significativos de sua respectiva mantissa) até eles se igualarem. Ex:325008 + 456003325008 -> mantissa = 325 e expoente = 8 -> Expande para 6 dígitos: mantissa = 325000 e expoente = 5Chegou no limite mas os números ainda não tem expoentes iguais, logo precisamos começar a incrementar o expoente menor (e excluir dígitos menos significativos):456003 -> mantissa = 456 e expoente = 3 -> Incrementa expoente: mantissa = 4 e expoente = 5Agora podemos somar as mantissas:325000 + 4 = 325004Resultado: mantissa = 325004 e expoente = 5 -> 325004005

[linhas,colunas] = size(matriz) http://www.mathworks.com/help/matlab/ref/size.html

Ainda há problemas, agora está dizendo que não há colisão quando há: Verifica se existe colisão!Insira x de Q1:4Insira y de Q1:2Insira altura de Q1:4Insira largura de Q1:4Insira x de Q2:2Insira y de Q2:4Insira altura de Q2:4Insira largura de Q2:4Não houve colisão É necessário checar todos os 4 vértices do primeiro retângulo em relação a área do segundo retângulo, e também fazer o oposto, checar os vértices do segundo retângulo em relação a área do primeiro.

Parece estar faltando informação sobre as especificações do problema. Pois, por que está sendo usada a notação "mantissa + 1 dígito indicador do sinal do expoente + 2 dígitos para indicar o expoente"? Isso significa que é obrigatório que os números sejam fornecidos em 1 único número inteiro? Ou seria permitido usar 2 números separados indicando mantissa e expoente? E existe um número máximo que pode ser usado, ou talvez um número máximo de dígitos da mantissa? Ou deve-se assumir o valor máximo da variável int? Pois isso é o que definiria a necessidade de descartar dígitos de menor relevância, como no caso do exemplo de soma fornecido, que descarta os 2 últimos dígitos do resultado da soma...

@CypherNet seu programa parece estar acusando colisão mesmo quando não há colisão, ou pelo menos quando testei estes valores ele afirmou que há colisão quando não há: Verifica se existe colisão!Insira x de Q1:2Insira y de Q1:2Insira altura de Q1:5Insira largura de Q1:5Insira x de Q2:10Insira y de Q2:10Insira altura de Q2:2Insira largura de Q2:2Colisão: BUMMMM

A área de um retângulo com coordenadas (A, B ), e comprimento L e altura H, contém todos os pontos (x, y) tal que: (x >= A) && (x <= A+L) && (y >= && (y <= B+H)Onde && representa a operação lógica E ou AND. A condição para que haja uma colisão entre 2 retângulos é que 1 dos 2 retângulos tenha pelo menos 1 ponto (x, y) que esteja dentro do outro retângulo. E como estamos lidando com retângulos é suficiente checar se pelo menos 1 dos 4 vértices do retângulo satisfazem a condição de estar dentro do outro retângulo. (Note que você deve checar os vértices de ambos os retângulos em relação a área do outro, pois pode haver uma situação em que 1 está totalmente contido no outro, ou que 2 vértices do mesmo lado estejam contidos no outro retângulo.)

Nesse caso o operador lógico a ser usado é o operador "e", não o operador "ou". Pois você quer que continue pedindo pro usuário digitar um operador enquanto OP for diferente de '+', e for diferente '-', e diferente de '*', e de '/'.

Sim. Uma possível solução seria esta: Pra pegar individualmente cada dígito em seqüência da direita para a esquerda, basta pegar o resto da divisão por 10 e então usar a divisão por 10 para eliminar o dígito obtido do número original: digito = n % 10;n = n / 10;Ex:45564 % 10 = 445564 / 10 = 45564556 % 10 = 64556 / 10 = 455455 % 10 = 5455 / 10 = 4545 % 10 = 545 / 10 = 44 % 10 = 44 / 10 = 0 Então basta fazer isso em ciclicamente até o número se tornar igual a 0... Tendo um dígito você pode compará-lo aos 10 dígitos possíveis (0, 1, 2, 3, 4, 5, 6, 7, 8 e 9), usando "switch case" ou vários "ifs", e incrementar o valor de um contador referente a este dígito (ou seja, haverá 1 contador para cada dígito, inicializado em 0). E se o valor do contador de um dado dígito atingir o valor 2 você deve incrementar o contador de dígitos que se repetem no número fornecido pelo usuário (que é o contador que deverá ser impresso no fim do programa).

Então jogo da velha é complexo demais pra o que você aprendeu até agora. Faça algo bem simples como um jogo de sorte, como uma loteria, ou rifa, ou jogo de dados.

Sugiro dar uma olhada nos notebooks da Avell e da Powernote. O fator limitante para jogos são as placas de vídeo, então é interessante consultar esta lista de desempenho das GPUs de notebooks em games (você pode selecionar os jogos que você joga ou pretende jogar na lista de jogos no topo da página, e clicar em restrict para ver exatamente o que te interessa).

O enunciado não especifica que se deseja calcular todas as batidas da bola nas paredes... Então vamos assumir que deseja-se apenas a primeira batida, o que simplifica bastante o problema. E a bola sempre começa no centro da mesa, o que também facilita bastante o problema. Primeiro é necessário decompor a força nas direções vertical e horizontal multiplicando-a por seno e cosseno de θ, respectivamente. Fv = -F * sen(θ) (o sinal negativo se deve ao fato do eixo Y crescer na direção de cima para baixo)Fh = F * cos(θ) Como a bola sempre começa no centro, a distância entre a bola e os lados superior e inferior é de 200 unidades, e de 100 unidades até os lados direito e esquerdo. Então, existe uma relação de 2 para 1 entre as distâncias aos lados. Logo, se a força na vertical for menor que o dobro da força horizontal a bola está indo em direção a um dos lados direito ou esquerdo, caso contrário está indo na direção de um dos lados superior ou inferior. |Fv| < |2 * Fh| -> Esquerda ou Direita|Fv| = |2 * Fh| -> Vértice|Fv| > |2 * Fh| -> Superior ou InferiorOnde | | indica valor absoluto ou módulo. Usando esta informação e o sinal positivo ou negativo de Fv ou Fh podemos distinguir para qual parede a bola está indo: |Fv| < |2 * Fh| :Fh < 0 -> EsquerdaFh > 0 -> Direita|Fv| > |2 * Fh| :Fv < 0 -> SuperiorFv > 0 -> Inferior|Fv| = |2 * Fh| :Fh < 0 e Fv < 0 -> Vértice Superior EsquerdoFh > 0 e Fv < 0 -> Vértice Superior DireitoFh < 0 e Fv > 0 -> Vértice Inferior EsquerdoFh > 0 e Fv > 0 -> Vértice Inferior Direito Resta saber se a bola vai chegar até a respectiva parede: Como cada unidade de força move a bola uma unidade de distância na vertical ou na horizontal, então basta saber se |Fv| é maior ou igual a 200 caso esteja indo para a parede superior ou inferior, para ter força suficiente para alcançar a parede. E se |Fh| é maior ou igual a 100 no caso das paredes esquerda e direita.

Tá ao contrário... Seria isto: v2[0] = v1[0]; for(i = 1; i < 10; i++) v2[i] = v2[i - 1] + v1[i];

Em C uma string é um vetor de caracteres (você já sabe o que é um vetor?), no caso do seu programa existe um vetor de caracteres (char) com 100 posições (0 até 99) para conter caracteres, e convenientemente este vetor foi chamado "string". E strings sempre acabam em um caracter nulo que é representado pelo caractere especial '\0'. Então se tivermos por exemplo a string: "abc 123" E a atribuirmos em uma string/vetor de caracteres, cada caractere será armazenado sequencialmente em uma posição do vetor, e no fim é acrescentado o caractere nulo '\0' que indica que a string termina ali (e que o que quer que esteja armazenado nas demais posições do vetor é irrelevante). Então teremos: string[0] == 'a'string[1] == 'b'string[2] == 'c'string[3] == ' 'string[4] == '1'string[5] == '2'string[6] == '3'string[7] == '\0' Note que espaço também é um caractere, assim como o caractere nova linha '\n'. Note também que um vetor de chars de 100 posições só pode armazenar uma string de no máximo 99 caracteres não nulos, pois nesse caso a última posição deverá armazenar o caractere nulo. Então vejamos o for do seu código: for (i=0; string[i] != '\0'; i=i+1) O que ele está fazendo ali é testar as posições do vetor de caracteres, percorrendo o vetor a partir de sua posição inicial (0), em sequência de 1 em 1, até encontrar a posição que contém o caractere nulo, ou seja, onde a string acaba. Para isso ele inicializa um contador "i" com valor zero e vai incrementando seu valor em 1 unidade (= soma 1) ao fim de cada ciclo. Então "i" vai contando 0, 1, 2, 3, 4, etc... E este número é usado para indicar a posição de cada caractere (string[0], string[1], string[2], etc...) que vai ser comparado ao caractere nulo, e o ciclo continua rodando enquanto o caractere for diferente de '\0', ou seja enquanto não chegar ao fim da string.

Não há diferença, é apenas uma questão de conveniência escolher um ou outro. Trata-se apenas de facilidade de leitura e entendimento do código.

Note que esta série da alternativa "e" é a série para calcular uma aproximação do número neperiano (ou número de Euler, ou número exponencial, ou como preferir chamá-lo): e = 2,718281828459045235360287..... Então é esperado que o programa obtenha um número que se aproxime mais de e quanto maior for o valor de n. Você chegou próximo da lógica ao notar que serie(n) = serie(n-1) + 1/n!, mas por algum motivo você está somando mais s, que sempre tem valor 0 (visto que s sempre é inicializado com valor s = 0 no começo da função), o que é desnecessário... E o maior problema é que você está calculando n! para depois fazer a divisão 1/n!, mas n! fica grande demais muito rapidamente conforme n aumenta, e aí chega no ponto em que uma variável do tipo inteiro (int) não consegue mais armazenar um valor tão grande, resultando em erros... O melhor modo de calcular 1/n! é notar que: 1/n! = 1/2 * 1/3 * 1/4 * ... * 1/n E que assim você não terá de calcular n!, que estoura o valor máximo que pode ser calculado rapidamente, mas apenas multiplicar várias frações para obter diretamente 1/n!.

Não, o enunciado já dá a descrição exata da função: mdc(u,v) = u se v=0 mdc(u;v) = mdc(v; u mod v), caso contrário. Só o que você precisa saber é que o módulo (mod) é o resto da divisão inteira... Logo a função fica: int mdc(int x, int y){ if (y == 0) return x; else return mdc(y, (x % y));} Agora, você pode verificar que isto funciona calculando alguns exemplos manualmente, e até dar uma pesquisada pra entender o fundamento matemático por trás deste método de cálculo de MDC.

Vamos escolher um número melhor pra explicar, como 66314. 66314 em binário com 32bits: 00000000000000010000001100001010Dividindo em 4 bytes: 00000000 00000001 00000011 00001010Se nós deslocarmos este número para a direita nestas quantidades de bits teremos: >> 24 bits - 00000000 00000000 00000000 00000000>> 16 bits - 00000000 00000000 00000000 00000001>> 8 bits - 00000000 00000000 00000001 00000011>> 0 bits - 00000000 00000001 00000011 00001010Mas observe nos 2 últimos casos que a parte que nos interessa são apenas os 8 bits mais a direita, entretanto existem números diferentes de 0 nas posições mais a esquerda destes bits, e precisamos eliminá-las antes de atribuir o valor ao char (que tem apenas 1 byte = 8 bits). Para isso usamos o valor hexadecimal 0xff (=255) que em binário é igual a: ...000011111111 (8 bits mais a direita 1, e o restante 0)E realizamos a operação booleana AND (que em C é simbolizado por &) entre o número deslocado e 0xff. Resultando que apenas os valores dos 8 bits mais a direita do número deslocado permanecem, e o restante a esquerda se torna 0, podendo então ser armazenado na variável char.Resultado final: >> 24 bits & 0xff - 00000000 00000000 00000000 00000000 = 00000000>> 16 bits & 0xff - 00000000 00000000 00000000 00000001 = 00000001>> 8 bits & 0xff - 00000000 00000000 00000000 00000011 = 00000011>> 0 bits & 0xff - 00000000 00000000 00000000 00001010 = 00001010

Não sei se isso é possível com ponteiros, mas acredito que você poderia obter isto usando deslocamentos de bits (se entendi corretamente o que você quer): unsigned char v[10];unsigned long x = 10;v[0] = (x >> 24) & 0xFF;v[1] = (x >> 16) & 0xFF;v[2] = (x >> 8) & 0xFF;v[3] = x & 0xFF;

Você precisa usar os argumentos argc (arguments counter) e argv (arguments values) no main, deste modo: int main(int argc, char *argv[]) Onde argc conterá o número total de argumentos, e argv será um vetor de strings onde cada argumento passado (separados por 1 espaço) será uma string, tal que a primeira string é o nome do próprio programa. Quando chamado: programa -parametro1 20 -parametro3 -parametro4 abcargc = 6argv[0] = "programa"argv[1] = "-parametro1"argv[2] = "20"argv[3] = "-parametro3"argv[4] = "-parametro4"argv[5] = "abc"

É aí não tenho como te ajudar, pois não tenho como fazer testes e verificar qual é o problema, acho que sua melhor chance seria algum fórum sobre enconders de audio e vídeo, talvez até algum específico sobre o ffmpeg, para dizer como resolver isto. Tem até um subforum aqui no Clube do Hardware sobre "edição de vídeo > codificação e compressão" que talvez tenha alguém que possa te ajudar.

Um "\n" antes do "%c" na entrada da operação também pode ser que funcione: scanf("\n%c",&operador);

Exatamente, o valor máximo para "e" seria 9, pois a partir de 10 a potência "10^e" fica muito grande (10^10) para ser armazenada numa variável do tipo "int", como a variável "pot10" usada no meu código. Mas é possível usar o tipo "long" (inteiro longo) ao invés de "int", que aumentaria o valor máximo de "e" para 18. Ou até testar os tipos "unsigned long", "long long" ou "unsigned long long", dependendo do compilador, para aumentar ainda mais o limite, mas eu acho que para esse exercício se 9 não for suficiente, eu imagino que "e" com valores indo até 18, usando "long", já atenderia a expectativa.

O programa vai pedir pro usuário digitar dois valores, e depois digitar o simbolo matemático da operação a ser realizada (soma "+", subtração "-", multiplicação "*", e divisão "/"). Aí seu programa deve realizar esta operação entre os 2 valores digitados e imprimir o resultado. Valor 1: 20Valor 2: 5Operacao (+ , - , * ou /): /Resultado: 4 E deve usar o "Selecione Caso" para selecionar o tipo de operação escolhida pelo usuário e então realizá-la. Em C isto é feito usando uma estrutura do tipo switch case, deste modo: switch (variavel) { case valor: break; case valor2: break; case valor3: break; ... default: break;}

Não existe 10^e em C, você precisa calcular essas potências usando um ciclo... E o comando de impressão printf está sendo usado de modo errado... Ele recebe uma string, e opcionalmente valores separados por vírgula. E a string pode conter caracteres de controle que indicam como formatar os valores separados por vírgula fornecidos (%d para números inteiros, %c para caracter, etc). Ex: printf("abcde %d %d 1234", 1000, 50) imprimirá 'abcde 1000 50 1234" no prompt... Ok, aqui está uma solução, só não me responsabilizo por plágios... #include <stdio.h>#include <stdlib.h>int main(){ int n, e, i, resto, pot10; printf("n: "); scanf("%d", &n); printf("e: "); scanf("%d", &e); if(e == 0){ printf("%d\n", n); } else { pot10 = 1; for(i=1; i<=e; i++) pot10 = pot10 * 10; //10^e printf("%d,", n/pot10); //Observe o uso correto de printf resto = n%pot10; for(i = e-1; i >= 0; i--){ pot10 = pot10/10; //Vai dividindo por 10 pra calcular as potências menores printf("%d", resto/pot10); resto = resto % pot10; } printf("\n"); } return 0;}

Observando o código do oliver vi que haveriam falhas na minha analise original, visto que números com 0 no meio retornariam respostas erradas seguindo aquela lógica (ex: n=1000023 e e=4 geraria resultado "100,23"). Aqui está a lógica revisada: se e for nulo: imprime nsenao: imprime n / (10^e) e "," resto = n % (10^e) para potencia indo de e-1 até 0 com decremento 1: imprime resto / (10^potencia) resto = resto % (10^potencia) fim do parafim do se Exs: n=210e=5n / 10^e = 210 / 10^5 = 0 | Prompt> 0,resto = 210 % 10^5 = 210potencia = e-1 = 4resto / 10^potencia = 210 / 10^4 = 0 | Prompt> 0,0resto = 210 % 10^4 = 210potencia = 3resto / 10^potencia = 210 / 10^3 = 0 | Prompt> 0,00resto = 210 % 10^3 = 210potencia = 2resto / 10^potencia = 210 / 10^2 = 2 | Prompt> 0,002resto = 210 % 10^2 = 10potencia = 1resto / 10^potencia = 10 / 10^1 = 1 | Prompt> 0,0021resto = 10 % 10^1 = 0potencia = 0resto / 10^potencia = 0 / 10^0 = 0 | Prompt> 0,00210resto = 0 % 10^0 = 0 n=10045e=3n / 10^e = 10045 / 10^3 = 10 | Prompt> 10,resto = 10045 % 10^3 = 45potencia = e-1 = 2resto / 10^potencia = 45 / 10^2 = 0 | Prompt> 10,0resto = 45 % 10^2 = 45potencia = 1resto / 10^potencia = 45 / 10^1 = 4 | Prompt> 10,04resto = 45 % 10^1 = 5potencia = 0resto / 10^potencia = 5 / 10^0 = 5 | Prompt> 10,045resto = 5 % 10^0 = 0