Hazzu

Poste seu código e podemos esclarecer suas dúvidas. Porém se não quiser ter trabalho, discord: Hazzu#7444

Favor utilizar a ferramenta inserção de código

Como todo descendente alterará o estado de todas as portas nais quais são múltiplas de seu identificador, as portas terão seus estado alterado div vezes, onde div é o número de divisores da porta. De fato, a porta 8 por exemplo, terá seu estado alterado 4 vezes, pelos descendentes 1, 2, 4 e 8 (divisores de 8). Desta forma, basta calcular a quantidade de divisores da porta para saber quantas vezes teve seu estado alterado e descobrir seu estado atual, visto que é dado o estado inicial (fechada). Repare que após uma quantidade par de mudança de estado, a porta sempre voltará a ficar fechada e, quando ímpar, esta estará aberta. Vamos ao código: //Programa: Portas Madame Rachel //Função: Calcular quais portas ficarão abertas na mansão da Madame Rachel //Autor: Hazzu#7444 //Data: 15/06/2020 //Cabeçalhos #include <stdio.h> #include <locale.h> //Função principal int main(){ //Declaração de variáveis int q, i, n, div; setlocale(LC_ALL, "Portuguese"); //Configurando terminal para português //Apresentação printf("------ Portas Madame Rachel ------\n"); printf("Olá, esse programa irá calcular quais portas ficarão abertas na mansão da Madame Rachel.\n"); //Solicitando número printf("-Digite a quantidade de quartos:\n"); scanf("%d", &n); //Avaliando estado final printf("Portas que ficarão abertas:\n"); for (q=1; q<=n; q++){ //Percorrendo quartos div = 0; for (i=1; i<=q; i++){ //Calculando numero de alterações de estado (divisores) if (q % i == 0) div++; } if (div % 2 == 1) printf("%d\n", q); } //Encerrando programa printf("Obrigado por utilizar o programa!\n"); return 0; } Um fato curioso que você pode notar ao inserir um alto valor para n é que todos os números são quadrados perfeitos. Isto ocorre porque todos números naturais com uma quantidade ímpar de divisores são quadrados perfeitos. De fato, como é demonstrado aqui. Sabendo disto, podemos otimizar nosso algorítimo imprimindo apenas os quadrados perfeitos de 1 a n. Vamos ao código: //Programa: Portas Madame Rachel //Função: Calcular quais portas ficarão abertas na mansão da Madame Rachel //Autor: Hazzu#7444 //Data: 20/06/2020 //Cabeçalhos #include <stdio.h> #include <locale.h> //Função principal int main(){ //Declaração de variáveis int r, n; setlocale(LC_ALL, "Portuguese"); //Configurando terminal para português //Apresentação printf("------ Portas Madame Rachel ------\n"); printf("Olá, esse programa irá calcular quais portas ficarão abertas na mansão da Madame Rachel.\n"); //Solicitando número printf("-Digite a quantidade de quartos:\n"); scanf("%d", &n); //Avaliando estado final printf("Portas que ficarão abertas:\n"); for (r = 1; r*r <= n; r++){ //Percorrendo raízes printf("%d ", r*r); } //Encerrando programa printf("\n\nObrigado por utilizar o programa!"); return 0; } Você pode comprovar a diferença gritante de eficiência ao informar o valor 999999999 para n às duas versões.

//Programa: Primo Fibonacci //Função: Obter todos os primos até o termo n da Sequência de Fibonacci //Autor: Hazzu#7444 //Data: 05/06/2020 //Cabeçalhos #include <stdio.h> #include <locale.h> //Função principal int main(){ //Declaração de variáveis int i, div, n, a=1, b=2, aux; setlocale(LC_ALL, "Portuguese"); //Configurando terminal para português //Apresentação printf("------ Primo Fibonacc ------\n"); printf("Olá, esse programa irá informar todos os primos da Sequência de Fibonnaci até o termo n.\n"); //Solicitando número printf("-Digite o valor de n:\n"); scanf("%d", &n); //Resultados triviais if (n > 0) printf("1 não é primo.\n"); if (n > 1) printf("1 não é primo.\n"); if (n > 2) printf("2 é primo!\n"); //Avaliando termos maiores for (i=4; i<=n; i++){ //Três termos da sequência já foram definidos, vamos começar no 4° //Calculando próximo termo aux = b; b += a; a = aux; //Testando se é primo for (div=2; div<=b/2; div++){ if (b%div == 0){ printf("%d não é primo.\n", b); break; } } if (div > b/2) printf("%d é primo!\n", b); } //Encerrando programa return 0; }

Já postei uma ótima apostila aqui no PasseiDireto, porém utiliza a linguagem Portugol (VisuAlg), que é bem simples.

Naturalmente. Seu algorítimo exibirá apenas os primos da Sequência de Fibonacci: 0,1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, ... Os números 7 e 11 não fazem parte da sequência, escopo de análise.

Posta o código inteiro e fala a função de todo o código

O número 1 terá apenas um divisor, caindo no else e aparecendo como primo. Do conceito de número primo, é necessário que ele possua exatamente dois divisores: 1 e ele mesmo. É mais consistente então você utilizar esta condição: if (primo==2) printf("%d e primo\n", auxiliar); else printf("%d não e primo\n", auxiliar);

Monitoria de C : Hazzu#0707 no discord

Poste seu código e posso apontar seus erros. Porém se quiser que alguém faça para você, é adequado pagar 😛

//Programa: Primo Próximo //Função: Obter o próximo primo a partir de um número inserido pelo usuário //Autor: Hazzu#7444 //Data: 04/06/2020 //Cabeçalhos #include <stdio.h> #include <locale.h> #include <math.h> //Assinatura das funções int primo(int n); //Função principal int main(){ //Declaração de variáveis int n, p; setlocale(LC_ALL, "Portuguese"); //Configurando terminal para português //Apresentação printf("------ Primo Próximo ------\n"); printf("Olá, esse programa irá calcular o número primo imediatamente superior ao valor informado.\n"); //Solicitando número printf("-Digite um número:\n"); scanf("%d", &n); //Buscando próximo primo p = n; do{ p+=1; } while(!primo(p)); //Saida de dados printf("O número primo imediatamente superior a %d é %d!\n", n, p); //Encerrando programa return 0; } //Função que determina se um número inteiro é primo int primo(int n){ //Declaração de variáveis int i, limit; n = abs(n); //Possibilitando trabalho com números negativos limit = (int) sqrt(n); //Basta testar divisores até a raiz do número if (n > 2){ //Procurando divisores for (i=2; i <= limit; i++){ if (n%i == 0) return 0; //False } } else if (n == 2){ return 1; //True } else{ return 0; //False } return 1; //Não encontrou divisores -> True }

Já desenvolvi uma função em C para resolução de sistemas lineares pelo método da Eliminação de Gauss. //Resolução de sistema linear através do Método da Eliminação Gaussiana float * Gauss(float ** M, int tam){ int i, l, j; float * S; float pivor[2]; float aux; S=AlocarVetor(tam); for (j=0; j<tam-1; j++){ pivor[0]=j; pivor[1]=M[j][j]; for (l=j+1; l<tam;l++){ //Procura do maior termo na coluna if ((float)fabs(M[l][j])>(float)fabs(pivor[1])){ pivor[0]=l; pivor[1]=M[l][j]; } } if ((int)pivor[0] != j){ for (l=j; l<=tam; l++){ //Colocando a linha com o maior termo no topo aux=M[(int)pivor[0]][l]; M[(int)pivor[0]][l]=M[j][l]; M[j][l]=aux; } } for (i=j+1;i<tam;i++){ //Escalonamento for (l=tam; l>=j; l--){ M[i][l]=M[i][l]-M[j][l]*(M[i][j]/M[j][j]); } } } //Solução S[tam-1]=M[tam-1][tam]/M[tam-1][tam-1]; for (i=tam-2; i>=0; i--){ aux=0; for (j=i+1; j<tam; j++) aux=aux+M[i][j]*S[j]; S[i]=(M[i][tam]-aux)/M[i][i]; } return S; } Onde M é a matriz ampliada do sistema e tam é o tamanho. A linguagem C oferece mais dificuldade em operações com matrizes devido a lógica de ponteiros e ausência de operações vetoriais.

Não entendi muito bem o enunciado. Melhore o português ai.

Eu ia ler seu código, identificar seu erro e sugerir uma solução, mas fui desencorajado pela ilegibilidade fornecida por ti. Favor utilizar a ferramenta de inserção de código.

Para o caso a = tamA, isso resultará falso e você acabará imprimindo a linha: que resultará no acesso a uma posição na memória não reservada para seu vetor (Falha de segmentação). Falha de segmentação é um erro que ocorre em programa quando este tenta acessar um endereço na memória RAM que está reservado para outro programa ou que não existe. Lembre-se que em C os índices das posições vetoriais começam em 0 e terminam em tam-1, fazendo com que a posição tam não exista.

Pesquise sobre métodos numéricos para cálculo de derivadas.

Existem várias formas de fazê-las. Para facilitar, estou admitindo todas semelhantes aos modelos sugeridos, sendo o tamanho apenas uma referência para a próximo arranjo de caracteres possível. Naturalmente, a medida que a complexidade da forma aumenta, é requerido uma maior interpretação algébrica/geométrica para construí-la. Aqui está um exemplo de como fazê-las. //Programa: ASCII Art //Função: formar figuras geométrica com caractere //Autor: Hazzu#7444 //Data: 11/05/2020 //Cabeçalhos #include <stdio.h> //Assinatura das funções void preenche(int n); void espaco(int n); //Função principal int main(){ //Declaração de variáveis int tam, i, j; //Moldura Losango printf("-Moldura Losango\n>Insira um tamanho:\n"); scanf("%d", &tam); for (i=tam; i>0; i--){ //Superior preenche(i); //Preenchimento esquerdo espaco(2*(tam-i)); //Espaçamento central preenche(i); //Preenchimento direito printf("\n"); //Quebra de linha } for (i=1; i<=tam; i++){ //Inferior preenche(i); //Preenchimento esquerdo espaco(2*(tam-i)); //Espaçamento central preenche(i); //Preenchimento direito printf("\n"); //Quebra de linha } //Ampulheta printf("-Ampulheta\n>Insira um tamanho:\n"); scanf("%d", &tam); //Superior for (i=0; i<tam; i++){ espaco(i); printf("\\"); espaco(2*(tam-i-1)); preenche(2*i+1); espaco(2*(tam-i-1)); printf("/"); printf("\n"); } for (i=tam-1; i>0; i--){ espaco(2*tam-1-i); printf("\\"); preenche(2*i-1); printf("/"); printf("\n"); } //Inferior for (i=0; i<tam-1; i++){ espaco(2*tam-2-i); printf("/"); preenche(2*i+1); printf("\\"); printf("\n"); } for (i=tam-1; i>=0; i--){ espaco(i); printf("/"); espaco(2*(tam-i-1)); preenche(2*i+1); espaco(2*(tam-i-1)); printf("\\"); printf("\n"); } //Encerrando programa return 0; } //Função que imprime o preechimento void preenche(int n){ while(n > 0){ printf("#"); n--; } } //Função que imprime o espaçamento void espaco(int n){ while (n > 0){ printf(" "); n--; } } Partição dos laços:

Poste sua tentativa e te guiaremos à solução.

A montagem de qualquer forma geométrica baseia-se na impressão de espaçamentos e preenchimentos. Visto que isto será recorrente, aconselho a definição das funções preenche e espaço. Aqui está um exemplo de resolução: //Programa: ASCII Art //Função: formar figuras geométrica com caractere //Autor: Hazzu#7444 //Data: 11/05/2020 //Cabeçalhos #include <stdio.h> //Assinatura das funções void preenche(int n); void espaco(int n); //Função principal int main(){ //Declaração de variáveis int tam, i, j; //Quadrado printf("QUADRADO\n>Insira um tamanho:\n"); scanf("%d", &tam); for (i=1; i<=tam; i++){ preenche(tam); } //Triângulo printf("TRIANGULO\n>Insira um tamanho:\n"); scanf("%d", &tam); for (i=tam; i>0; i--){ preenche(i); } //Triângulos espelhados printf("TRIANGULOS ESPELHADOS\n>Insira um tamanho:\n"); scanf("%d", &tam); for (i=tam; i>0; i--){ //Triângulo regular preenche(i); } for (i=1; i<=tam; i++){ //Triângulo invertido preenche(i); } //Losango printf("LOSANGO\n>Insira um tamanho:\n"); scanf("%d", &tam); if (tam%2 == 0){ //Par for (i=2; i<=tam; i+=2){ //Triangulo regular espaco((tam-i)/2); preenche(i); } for (i=tam; i>0; i-=2){ //Triangulo invertido espaco((tam-i)/2); preenche(i); } } else{ //Ímpar for (i=1; i<=tam-2; i+=2){ //Triangulo regular espaco((tam-i)/2); preenche(i); } preenche(tam); //Faixa central for (i=tam-2; i>0; i-=2){ //Triangulo invertido espaco((tam-i)/2); preenche(i); } } //Encerrando programa return 0; } //Função que imprime o preechimento void preenche(int n){ int i; for (i=1; i <= n; i++) printf("*"); printf("\n"); } //Função que imprime o espaçamento void espaco(int n){ int i; for (i=1; i <= n; i++) printf(" "); }

//Programa: MaiorMenor //Função: Identificar o maior e o menor número dentre 5 informados //Autor: Hazzu#7444 //Data: 10/05/2020 //Cabeçalhos #include <stdio.h> //Função principal int main(){ //Declaração de variáveis int i, n, maior, menor; //Lendo numeros for (i=1; i<=5; i++){ printf("Informe o numero %d:\n", i); scanf("%d", &n); if (i==1){ //Inicializando valores menor = n; maior = n; } else{ //Comparando valores if (n < menor) menor = n; if (n > maior) maior = n; } } //Imprimindo maior e menor printf("Menor numero: %d\nMaior numero: %d\n", menor, maior); //Encerrando programa return 0; }

Acredito que esta seja a melhor solução. //Programa: MegaSena //Função: Sugerir apostas para a mega sena //Autor: Hazzu#7444 //Data: 10/05/2020 //Cabeçalhos #include <stdio.h> #include <stdlib.h> #include <time.h> //Função principal int main(){ //Declaração de variáveis int numeros[15]; int tam, i, j, repetido; //Solicitando quantidade de números da aposta do{ printf("Digite a quantidade de numeros da aposta (de 6 a 15):\n"); scanf("%d", &tam); } while(tam<6 || tam>15); //Sorteando numeros srand(time(NULL)); //Semente for (i=0; i<tam; i++){ do{ numeros[i] = rand() % 60 + 1; //Valores de 1 a 60 repetido = 0; //False for (j=0; j<i; j++){ if (numeros[j] == numeros[i]) repetido = 1; //Verdadeiro } } while (repetido); //Os numeros da mega sena não podem repetir } //Imprimindo números sorteados printf("Se eu fosse voce, apostaria nestes numeros:\n"); for (i=0; i<tam; i++){ printf("%d ", numeros[i]); } printf("\nBoa sorte!\n"); //Encerrando programa return 0; }

Ajude quem quer te ajudar. Poste seu código utilizando a ferramenta de inserção de código (quarto ícone do menu).

Me deve um salgado. //Cabeçalhos #include <stdio.h> //Assinatura das funções int soma_dig(int n); //Função principal int main(){ //Declaração de variáveis int numero; //Solicitando número printf("Digite um numero:\n"); scanf("%d", &numero); //Imprimindo soma dos dígitos printf("A soma dos digitos de %d é %d!\n", numero, soma_dig(numero)); //Encerrando programa return 0; } //Função recursiva que calcula a soma dos digitos int soma_dig(int n){ if (n < 10) return n; return n % 10 + soma_dig(n / 10); }

Qual a sua dúvida?

Poste o código que está tentando fazer e eu posso te ajudar