Exercícios de Revisão (Soluções)
Exercícios de Revisão (Soluções)
1. Dizemos que um inteiro positivo n é perfeito se for igual à soma de seus divisores positivos diferentes de n.
Exemplo: 6 é perfeito, pois 1+2+3 = 6. Dado um inteiro positivo n, verificar se n é perfeito.
Uma solução:
#include <stdio.h>
int main()
{ int n, i, soma = 0;
printf("Entre com o valor de n:");
scanf("%d", &n);
for(i=1; i<n; i++)
{ if( n%i == 0 ) //n é divisível por i
{ soma = soma + i;
}
}
if( soma == n )
{ printf("\n%d é perfeito\n", n);
}
else
{ printf("\n%d não é perfeito\n", n);
}
return 0;
}
2. Dado um número natural na base binária, transformá-lo para a base decimal.
Exemplo: Dado 10010 a saída será 18, pois 1. 2^4 + 0. 2^3 + 0. 2^2 + 1. 2^1 + 0. 2^0 = 18.
Uma solução:
#include <stdio.h>
int main()
{ int n, mult=1, soma=0;
printf("\nEntre o numero em binario: ");
scanf("%d", &n);
while( n > 0)
{ soma = soma + (n%10)*mult;
printf("%d . ", n%10);
printf("%d\n", mult);
n= n/10;
mult = mult * 2;
}
printf("\nConversao em decimal = %d\n", soma);
return 0;
}
Outra solução:
#include <stdio.h>
int main() {
int n, //número a converter
copia, //cópia do valor original
resto, //resto da divisão por 10
quociente, // resultado da divisão por 10
potenciaDe2 = 1, //primeira potência de 2 .... 2^0 = 1
soma = 0; //soma acumulada das parcelas da conversão
printf("Entre com um número em binário:");
scanf("%d", &n);
copia = n;
while(n>0)
{
quociente = n/10;
resto = n%10;
soma = soma + resto * potenciaDe2;
n = quociente;
potenciaDe2 = potenciaDe2 * 2;
}
printf("%d corresponde a %d", copia, soma);
return 0;
}
Agora outra solução usando strings:
#include <stdio.h>
#include <string.h>
int main()
{ char entrada[50];
printf("Entre com o número em binário:");
gets(entrada);
int tamanho = strlen(entrada);
int i, soma = 0, potenciaDe2 = 1;
for(i=tamanho-1; i>=0; i--)
{ soma = soma + (entrada[i] - '0')*potenciaDe2;
potenciaDe2 = potenciaDe2 * 2;
}
printf("Resultado = %d\n", soma);
return 0;
}
3. Dado um número natural na base decimal, transformá-lo para a base binária.
Exemplo: Dado 18 a saída deverá ser 10010.
Dica e explicação da ideia:
18 |__2__
0 9 |__2__
<- 1 4 |__2__
<- 0 2 |__2__
<- 0 1 |__2__
<- 1 0
<-
(10010) == (18)
2 10
0 x 1 = 0
1 x 10 = 10
0 x 100 = 0
0 x 1000 = 0
1 x 10000 = 10000 +
---------------------
10010
Uma solução:
#include <stdio.h>
int main()
{ int n, mult=1, soma=0,a;
printf("\nEntre o numero em decimal: ");
scanf("%d", &n);
while( n > 0)
{ soma = soma + (n%2)*mult;
a= n%2;
printf ("\n%d = %d + %d x %d\n",soma,soma,a,mult);
printf("%d . ", n%2);
printf("%d\n", mult);
n= n/2;
mult = mult * 10;
}
printf("\nConversao em binario = %d\n", soma);
return 0;
}
Outra solução:
#include <stdio.h>
int main() {
int n, resto, quociente;
int vet[32], i = 0, j;
printf("Entre com um número em notação decimal:");
scanf("%d", &n);
while(n>0)
{
quociente = n/2;
resto = n%2;
vet[i] = resto;
i++;
n = quociente;
}
for(j=i-1; j>=0; j--)
printf("%d", vet[j]);
return 0;
}
4. Dados n e uma sequência de n números inteiros, determinar quantos segmentos de números iguais consecutivos compõem essa sequência.
Exemplo: A seguinte sequência é formada por 5 segmentos de números iguais: 5, 2, 2, 3, 4, 4, 4, 4, 1, 1
Ou seja, contarei assim: <<5>>,<< 2, 2>>,<< 3>>,<< 4, 4, 4, 4>>, <<1, 1>>
Portanto, tenho 5 grupos.
Uma solução:
#include <stdio.h>
int main()
{ int vet[]={5, 2, 2, 3, 4, 4, 4, 4, 1, 1};
int soma=1, tam=10, i;
for(i=1; i<tam; i++)
{ //se o elemento da posição i for diferente
//do elemento anterior, conto mais um grupo
if(vet[i] != vet[i-1])
soma = soma + 1;
}
printf("\nHa %d grupos de elementos repetidos\n", soma);
return 0;
}
Outra solução:
#include <stdio.h>
int main()
{ int N, i, grupos = 1;
printf("Quantos números serão digitados?");
scanf("%d", &N);
int vet[N];
printf("Digite os %d números:", N);
scanf("%d", &vet[0]); //leitura do primeiro elemento
for(i=1; i<N; i++)
{ scanf("%d", &vet[i]);
if(vet[i] != vet[i-1])
grupos++;
}
printf("Há %d grupos", grupos);
return 0;
}
Outra solução com Fru-fru:
#include <stdio.h>
int main()
{ int vet[] = {5, 2, 2, 3, 4, 4, 4, 4, 1, 1}, N=10;
int grupos = 1;
int i = 1; //índice do segundo elemento
printf("<<%d", vet[0]);
while(i < N)
{ if(vet[i] != vet[i-1])
{ grupos++;
printf(">> <<%d", vet[i]);
}
else
{ printf(" %d", vet[i]);
}
i++;
}
printf(">>\n");
printf("Há %d grupos", grupos);
return 0;
}
5. Dados n e uma sequência de n números inteiros, determinar o comprimento de um segmento crescente de comprimento máximo.
Exemplos:
Na sequência 5, 10, 3, <<2, 4, 7, 9>>, 8, 5 o comprimento do segmento crescente máximo é 4.
Na sequência 10, 8, 7, 5, 2 o comprimento de um segmento crescente máximo é 1.
Uma solução:
#include <stdio.h>
int main()
{ int vet[]={5, 10, 3, 2, 4, 7, 9, 8, 5}, N=9;
//int vet[]={10, 8, 7, 5, 2}, N=5;
int cont=1, max=1, i;
for(i=1; i<N; i++)
{ if(vet[i] > vet[i-1]) cont++;
else cont = 1;
if(cont > max) max = cont;
}
printf("\nTamanho maximo crescente da sequencia = %d\n", max);
return 0;
}
6. Dados dois números naturais m e n e duas sequências ordenadas com m e n números inteiros, obter uma única sequência ordenada contendo todos os elementos das sequências originais sem repetição.
Sugestão: Imagine uma situação real, por exemplo, dois fichários de uma biblioteca.
Exemplo:
Sequência 1: 1, 1, 2, 3, 4, 8, 9
Sequência 2: 1, 3, 5, 7, 10
Sequência gerada (sem repetição): 1, 2, 3, 4, 5, 7, 8, 9, 10
Uma solução:
#include <stdio.h>
int main()
{ int seq1[] = { 1, 1, 2, 3, 4, 8, 9 };
int seq2[] = { 1, 3, 5, 7, 10 };
int N1 = 7, N2 = 5;
int N3 = N1 + N2;
int seq3[N3]; //sequência com repetições
int seq4[N3], N4=0; //sequência sem as repetições
int i=0, j=0, k=0;
while(i<N1 && j<N2)
{ if(seq1[i] < seq2[j])
{ seq3[k] = seq1[i];
i++;
k++;
}
else
{ seq3[k] = seq2[j];
j++;
k++;
}
//if(seq1[i] < seq2[j]) seq3[k++] = seq1[i++];
//else seq3[k++] = seq2[j++];
}
if(i >= N1) //a sequência 1 que terminou
{ for( ; j<N2; j++, k++)
seq3[k] = seq2[j];
}
else //a sequência 2 que terminou
{ for( ; i<N1; i++, k++)
seq3[k] = seq1[i];
}
//imprimindo a seq3 (com repetições)
printf("Sequência 3 (com repetições):\n");
for(k=0; k<N3; k++)
printf("%d ", seq3[k]);
printf("\n");
seq4[0] = seq3[0];
N4 = 1;
for(k=1; k<N3; k++)
{ if(seq3[k] != seq4[N4-1])
{ seq4[N4] = seq3[k];
N4++;
}
}
//imprimindo a seq4 (sem repetições)
printf("Sequência 4 (sem repetições):\n");
for(k=0; k<N4; k++)
printf("%d ", seq4[k]);
printf("\n");
return 0;
}
Outra solução:
#include <stdio.h>
int main()
{ int seq1[] = {1, 1, 2, 3, 4, 8, 9};
int seq2[] = {1, 3, 5, 7, 10};
int n1 = 7, n2 = 5, n3 = n1+n2;
int seq3[n3];
int i1 = 0, i2 = 0, i3 = 0;
//Coloca apenas um número menor na seq3[0]
if(seq1[i1] < seq2[i2])
{ seq3[i3] = seq1[i1];
i1++;
}
else
{ seq3[i3] = seq2[i2];
i2++;
}
i3++;
while(i1 < n1 && i2 < n2)
{ if(seq1[i1] < seq2[i2]) //elemento da seq1 é menor
{ if(seq1[i1] != seq3[i3-1]) //elemento da seq1 não é repetido
{ seq3[i3] = seq1[i1];
i1++;
i3++;
}
else i1++; //elemento da seq1 é repetido
}
else //elemento da seq2 é menor (ou são iguais)
{ if(seq2[i2] != seq3[i3-1]) //elemento da seq2 não é repetido
{ seq3[i3] = seq2[i2];
i2++;
i3++;
}
else i2++; //elemento da seq2 é repetido
}
}
if(i1 < n1) //copio o resto que sobrou em seq1
{ for( ; i1<n1; i1++, i3++)
seq3[i3] = seq1[i1];
}
else //copio o resto que sobrou em seq2
{ for( ; i2<n2; i2++, i3++)
seq3[i3] = seq2[i2];
}
//mostro a sequência gerada
n3 = i3;
for(i3 = 0; i3<n3; i3++)
printf("%d ", seq3[i3]);
return 0;
}
7. Dadas duas sequências com n números inteiros entre 0 e 9, interpretadas como dois números inteiros de n algarismos, calcular a sequência de números que representa a soma dos dois inteiros.
Exemplo: n = 8,
1ª sequência 8 2 4 3 4 2 5 1
2ª sequência 3 3 7 5 2 3 3 7 +
-----------------------
1 1 6 1 8 6 5 8 8
Uma solução:
#include <stdio.h>
int main()
{ int num1[] = {8, 2, 4, 3, 4, 2, 5, 1};
int num2[] = {3, 3, 7, 5, 2, 3, 3, 7};
int n = 8;
int soma[n+1];
int i, vaium = 0;
for(i = n-1; i >= 0; i--)
{ soma[i + 1] = (num1[i] + num2[i] + vaium) % 10;
vaium = (num1[i] + num2[i] + vaium) / 10;
}
soma[0] = vaium;
for(i=0; i < n+1; i++)
printf("%d ", soma[i]);
return 0;
}
8. Imprimir as n primeiras linhas do triângulo de Pascal. Você pode fazer com uma matriz ou mesmo utilizando um único vetor.
Dicas:
a) a primeira coluna sempre contém 1.
b) o último elemento de cada linha sempre é 1.
c) todos os outros elementos podem ser calculados somando-se o de cima com o de cima à esquerda.
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
:
Uma solução:
#include <stdio.h>
int main()
{ int N;
printf("Quantas linhas devo mostrar?");
scanf("%d", &N);
int mat[N][N];
int l, c;
for(l=0; l<N; l++)
{ mat[l][0] = 1;
mat[l][l] = 1;
}
for(l=2; l<N; l++)
{ for(c=1; c<l; c++)
{ mat[l][c] = mat[l-1][c] + mat[l-1][c-1];
}
}
for(l=0; l<N; l++)
{ for(c=0; c<=l; c++)
{ printf("%5d", mat[l][c]);
}
printf("\n");
}
return 0;
}
Outra solução:
#include <stdio.h>
int main()
{ int N;
printf("Quantas linhas devo mostrar?");
scanf("%d", &N);
int vet[N];
int l, c;
vet[0] = 1;
for(l=0; l<N; l++)
{ vet[l] = 1;
for(c=l-1; c>=1; c--)
{ vet[c] = vet[c] + vet[c-1];
}
for(c=0; c<=l; c++)
{ printf("%5d", vet[c]);
}
printf("\n");
}
return 0;
}
Comentários
Postar um comentário