Escreva uma função que recebe dois inteiros x e y e devolve os valores de x e y trocados.
#include <stdio.h>
void troca_errada(int x, int y);
void troca_certa(int *x, int *y);
int main(){
int valor1, valor2;
printf("Digite dois valores inteiros: ");
scanf("%d %d", &valor1, &valor2);
troca_errada(valor1, valor2);
printf("Depois da troca errada: valor1 = %d , valor2 = %d \n", valor1, valor2);
troca_certa(&valor1, &valor2);
printf("Depois da troca certa: valor1 = %d , valor2 = %d \n", valor1, valor2);
return 0;
}
void troca_errada(int x, int y){
int z;
z = x;
x = y;
y = z;
}
void troca_certa(int *x, int *y){
int z;
z = *x;
*x = *y;
*y = z;
}
Dizemos que um número natural n é palíndromo se lido da direita para a esquerda ou da esquerda para a direita é o mesmo número. Exemplos:
567765 e 32423 são palíndromos. 567675 não é palíndromo. Socorram-me subi no onibus em Marrocos. Oto come doce seco de mocotó. A diva em Argel alegra-me a vida.
n > 0 e devolve o seu primeiro dígito, seu último dígito e altera o valor de n removendo seu primeiro e último dígitos. Exemplos:| valor inicial de n | primeiro dígito | último dígito | valor final de n |
| 732 | 7 | 2 | 3 |
| 14738 | 1 | 8 | 473 |
| 1010 | 1 | 0 | 1 |
| 78 | 7 | 8 | 0 |
| 7 | 7 | 7 | 0 |
n e verifica se n é palíndromo. Suponha que n não contém o dígito 0.#### Solução
#include <stdio.h>
#define TRUE 1
#define FALSE 0
void descasca(int *n, int *primeiro_digito, int *ultimo_digito);
int main(){
int n, primd, ultd, palindromo = TRUE;
printf("Digite um numero inteiro positivo que não contém zero(s): ");
scanf("%d", &n);
while (palindromo && n > 9){
descasca(&n, &primd, &ultd);
if (primd != ultd)
palindromo = FALSE;
}
if (palindromo)
printf("O numero eh palindromo!");
else
printf("O numero nao eh palindromo!");
return 0;
}
void descasca(int *n, int *primeiro_digito, int *ultimo_digito){
int pot10 = 10;
if (*n > 0) {
*ultimo_digito = *n % 10;
*n = *n / 10;
while (pot10 < *n)
pot10 *= 10;
pot10 /= 10;
*primeiro_digito = *n / pot10;
*n = *n % pot10;
}
else {
*primeiro_digito = 0;
*ultimo_digito = 0;
}
}
int divide (int *m, int *n, int d);
que recebe três inteiros positivos como parâmetros e retorna 1 se d divide pelo menos um entre *m e *n, e 0 caso contrário. Fora isso, se d divide *m, divide *m por d, e o mesmo para *n.
m e n e calcula, usando a função acima, o mínimo múltiplo comum entre m e n.#include <stdio.h>
int divide(int *m, int*n, int d);
int main() {
int m, n, qm, qn, d, mmc;
printf("Digite m e n: ");
scanf("%d %d", &m, &n);
d = 2;
mmc = 1;
qm = m;
qn = n;
while (qm != 1 || qn != 1)
if (divide(&qm, &qn, d))
mmc = mmc * d;
else
d = d + 1;
printf("mmc(%d, %d) = %d \n", m, n, mmc);
return 0;
}
int divide(int *m, int*n, int d) {
int resp = 0;
if (*m % d == 0) {
*m = *m/d;
resp = 1;
}
if (*n % d == 0) {
*n = *n/d;
resp = 1;
}
return(resp);
}
void somabit (int b1, int b2, int *vaium, int *soma);
que recebe três bits (inteiros 0 ou 1) b1, b2 e *vaium e retorna um bit soma representando a soma dos três e o novo um bit "vai-um" em *vaium.
#### Solução
#include <stdio.h>
void somabit (int b1, int b2, int *vaium, int *soma) {
*soma = (b1 + b2 + *vaium) % 2;
*vaium = (b1 + b2 + *vaium) / 2;
}
int main() {
int m, n, qm, qn, vaium, dig, resp, pot;
printf("Digite m e n: ");
scanf("%d %d", &m, &n);
vaium = 0;
resp = 0;
pot = 1;
qm = m;
qn = n;
while (qm!=0 || qn!=0) {
somabit(qm%10, qn%10, &vaium, &dig);
qm = qm/10;
qn = qn/10;
resp = resp + pot*dig;
pot = pot * 10;
}
resp = resp + pot * vaium;
printf("%d + %d = %d \n", m, n, resp);
return 0;
}
void minimos_quadrados (float x[MAX], float y[MAX], int n, float *a, float *b);
que recebe dois vetores x e y com n números reais, onde y está ordenado e não tem repetição, e devolve os valores de a e b, calculados como no EP3.
n e duas sequências x e y com n números reais, a primeira delas ordenada e sem repetição, e devolve os coeficientes da interpolação linear do método dos mínimos quadrados.#include <stdio.h>
#define MAX 1000
float media(float x[MAX], int n);
void minimos_quadrados(float x[MAX], float y[MAX], int n, float *a, float *b);
int main(){
int n, i;
float x[MAX], y[MAX], a, b;
printf("Digite o tamanho n das sequências: ");
scanf("%d", &n);
for (i = 0; i < n; i++){
printf("Digite os valores de x e y para a %d-esima posicao: ", i+1);
scanf("%f %f", &x[i], &y[i]);
}
minimos_quadrados(x, y, n, &a, &b);
printf("Os coeficientes da interpolacao linear sao: a = %f e b = %f", a, b);
return 0;
}
float media(float x[MAX], int n) {
int i;
float m = 0;
for (i = 0; i < n; i++)
m += x[i];
return m / n;
}
void minimos_quadrados(float x[MAX], float y[MAX], int n, float *a, float *b) {
float numerador = 0, denominador = 0, mediax, mediay;
int i;
mediax = media(x,n);
mediay = media(y,n);
for(i = 0; i < n; i++) {
numerador = x[i] * (y[i] - mediay);
denominador = x[i] * (x[i] - mediax);
}
*b = numerador / denominador;
*a = mediay - *b * mediax;
}