Todas As Fichas Resolvidas

Ficha 1
1: Soma e diferença
#include <stdio.h>
int main (void) {
int a;
int b;
int soma;
int diferenca;
printf("Introduza um valor inteiro para a: ");
scanf("%d", &a);
printf("Introduza um valor inteiro para b: ");
scanf("%d", &b);
soma = a + b;
diferenca = a - b;
printf("A soma dos valores dados e %d e a diferenca e %d", soma, diferenca);
return 0;
2: Produto entre inteiro e real
#include <stdio.h>
int main(void) {
int a;
float b;
float produto;
printf("Introduza um valor inteiro para a: ");
scanf("%d", &a);
printf("Introduza um valor real para b: ");
scanf("%f", &b);
produto = a * b;
printf("O valor do produto entre os alores e: %f", produto);
return 0;
3: área de um retângulo
int main (void) {
float base;
float altura;
float area;
printf("Introduza um valor para a base do retangulo: ");

scanf("%f", &base);
printf("Introduza um valor para a altura do retandulo: ");
scanf("%f", &altura);
area = base * altura;
printf("O valor da area do retangulo e: %f", area);
return 0;
4: preco + IVA
#include <stdio.h>
int main (void) {
float preco;
int taxa;
float total;
printf("Introduza o preço do produto: ");
scanf("%f", &preco);
printf("Introduza o valor da taxa IVA: ");
scanf("%d", &taxa);
total = preco * taxa;
printf("O valor do produto com imposto aplicado e %f", total);

return 0;
5: media das notas
#include <stdio.h>
int main (void) {
int a;
int b;
float nota;
printf("Introduza a nota da primeira discilplina (inteiros): ");
scanf("%d", &a);
printf("Introduza a nota da segunda disciplina: ");
scanf("%d", &b);
nota = (a + b) / 2;
printf("A media das notas e %f", nota);
return 0;
6; conversor de kg para g
#include <stdio.h>
int main(void) {
float kg;
float gramas;
printf("Introduza a massa em Kg: ");
scanf("%f", &kg);
gramas = kg / 1.000;
printf("O valor do quilo em gramas e de %f", gramas);
return 0;
7: Converter graus C para F
#include <stdio.h>
int main (void) {
float c;
float f;
printf("Introduza o valor da temperatura em graus celsius: ");
scanf("%f", &c);
f = (c * 9/5) + 32;
printf("O valor da temperatura em F e: %f", f);
return 0;
8: horas, minutos e segundos
#include <stdio.h>
int main (void) {
int segundos;
int horas;
int minutos;
int horario;
printf("Introduza um valor inteiro em segundos: ");
scanf("%d", &segundos);
horas = segundos / 3600;
minutos = (segundos / 3600) / 60;
segundos = segundos;
printf(" O horario e %d:%d:%d", horas, minutos, segundos);
return 0;
}
9: transformar real em inteiro e fracioanaria
#include <stdio.h>
int main (){
int numerointeiro;
printf("introduza um numero inteiro:");
scanf("%d", &numerointeiro);
if(numerointeiro%2==0)
printf("numeropar");
else
printf("numeroimpar");
return 0;
Ficha 2
1: Verificar se é par ou impar
#include <stdio.h>
int main(void) {
int numero;
printf("Introduza um valor inteiro: ");
scanf("%d", &numero);
if(numero%2==0)
printf("O numero %d e par", numero);
else
printf("O numero %d e impar", numero);
return 0;
2: Comparar 3 valores e verificar qual é o maior
#include <stdio.h>
int main(void){
int a;
int b;
int c;
printf("Introduza tres valores inteiros: ");
scanf("%d%d%d", &a, &b, &c);
if(a>b && a>c)
printf("%d e o maior valor", a);
if(b>a && b>c)
printf("%d e o maior valor", b);
if(c>a && c>b)
printf("%d e o maior valor", c);

return 0;
3: resto da divisão do maior inteiro pelo menor
#include <stdio.h>
int main(void) {
int a;
int b;
float resto;
printf("Introoduza dois valores inteiros: ");
scanf("%d%d", &a, &b);
if(a>b) {
resto = a % b;
printf("O resto da divisao de %d sobre %d e %f", a, b, resto);
}else
printf("O resto da divisao de %d sobre %d e %f", b, a, resto);
return 0;
4: Verificar se o inteiro e divisível por 3
#include <stdio.h>
int main (void) {

int a;
printf("Introduza um valor inteiro: ");
scanf("%d", &a);
if(a % 3 == 0)
printf("O valor %d e divisivel por 3!",a);
else
printf("%d nao e divisel por 3", a);
return 0;
5: calcular o valor de x da função dada
6: imposto a pagar pelo ordenado
#include <stdio.h>
int main(void) {
float ordenado;
float excedente;
float taxa;
printf("Introduza o valor do ordenado anual: ");
scanf("%f", &ordenado);
if(ordenado <= 8.000) {

taxa = ordenado * 5/100;
printf("O valor da taxa a ser paga e %f", taxa);
}else
taxa = ordenado * 9/100;
printf("O valor total da taxa sobre o ordenado e %f", taxa);
return 0;
7: IMC
#include <stdio.h>
int main (void) {
float peso;
float altura;
float imc;
printf("Introduza o valor do peso em kg: ");
scanf("%f", &peso);
printf("Introduza o valor da altura em metros: ");
scanf("%f", &altura);
imc = peso / (altura*altura);

if(imc<19)
printf("magreza");
if(19 < imc < 25)
printf("normal");
if(26 < imc <30)
printf("excesso de peso");
if(31 < imc <= 40)
printf("obesidade");
if(imc > 41)
printf("obesidade morbida");
return 0;
Ficha 3
1: Numeros impares até 100
#include <stdio.h>
int main(void) {
int i;
i = 1;
while(i <=100)
printf("%d\n", i);
i = i + 2;
return 0;
2: produto dos ímpares de x a y
#include <stdio.h>
int main (void) {
int i;
int prod;
prod = 1;
for( i = 1 ; i <= 10 ; i+=2)
prod = prod * i;
printf("O produto e %d", prod);
return 0;
3: números pares entre a e b
#include <stdio.h>
int main () {
int i, a, b;
printf("introduza dois valores inteiros: ");
scanf("%d%d", &a, &b);
if(a<b) {
for(i=a; i<b; i++)
if (i%2==0)
printf("%d\n", i);
} else {
for(i=b; i<a; i++)
if(i%2==0)
printf ("%d\n", i);
return 0;
4: soma dos N números
#include <stdio.h>
int main (void) {
int n;
int i;
int soma;
soma = 0;
printf("Introduza o valor de N: ");
scanf("%d", &n);
for( i = 0 ; i < n ; i++)
soma = soma + i;
printf("A soma dos numeros e %d", soma);
return 0;
5: soma de n
#include <stdio.h>
int main(void) {
int n;
int i;
int soma;
printf("Introduza um valor inteiro positivo: ");

scanf("%d", &n);
for( i = 1 ; i <= n ; i++)
soma = i+1;
printf("A soma dos valores de n e %d", soma);
return 0;
6: o maior e menor valor (zero para terminar a introdução de sequencia)
#include <stdio.h>
int main() {
int n;
int maior;
int menor;
printf("Introduza um valor (0 para terminar): ");
scanf("%d", &n);
maior = menor = n;
while (n != 0) {
printf("Introduza um valor (0 para terminar): ");
scanf("%d", &n);
if (n != 0) {
if (n > maior) {
maior = n;
if (n < menor) {
menor = n;
printf("O maior valor é: %d\n", maior);
printf("O menor valor é: %d\n", menor);
return 0;
7: valor absoluto
#include <stdio.h>
#include <math.h>
int main () {
float maiornumero=0, x, y;
int numero, i=0;
printf("Introduza a quantidade de valores pretendidos: ");
scanf("%d", &numero);
do{
printf("Introduza o valor: ");
scanf("%f", &x);
x = fabs(x);
if (maiornumero<x)
maiornumero=x;
i++;
} while (i<numero);
printf("O maior valor absoluto digitado foi: %f", maiornumero);
return 0;
8: fatorial
#include <stdio.h>
int main() {
int valor, i;
int fat=1;
printf("Introduza um valor para calcular o seu fatorial: ");
scanf("%d", &valor);
while (valor <= 0) {
printf("O valor introduzido nao e valido, defina um valor inteiro e positivo: ");
for (i = 1; i <= valor; ++i) {
fat *= i;
printf("O fatorial de %d e %d", valor, fat);

return 0;
9: somatório
#include <stdio.h>
int main() {
int n;
double soma = 0.0;
printf("Insira um valor inteiro n maior que 1: ");
scanf("%d", &n);
if (n <= 1) {
printf("Por favor, insira um valor maior que 1 para n.\n");
return 1;
for (int k = 1; k <= n; ++k) {
soma += 1.0 / k;
printf("O valor do somatório de 1/k para k de 1 a %d é: %f\n", n, soma);
return 0;
}
Ficha 4
1: perímetro e área com repetição
#include <stdio.h>
int main(void) {
float raio;
float perimetro;
float area;
const float pi = 3.14;
char resposta;
do {
printf("Introduza o valor do raio do circulo: ");
scanf("%f", &raio);
perimetro = 2 * pi * raio;
area = pi * raio * raio;
printf("O perimetro do circulo tem o valor de %f e a area de %f\n", perimetro, area);
printf("Deseja continuar a operacao? (digite 'sim' para continuar): ");
scanf(" %c", &resposta);
} while (resposta == 's' || resposta == 'S');
printf("Programa encerrado.\n");
return 0;
}
2: Média de N valores inteiros
#include <stdio.h>
int main(void) {
float valor;
float media;
int quantidade;
float soma;
int i = 0;
printf("Defina a quantidade de valores a ser utilizado: ");
scanf("%d", &quantidade);
while( i < quantidade){
printf("Introduza um valor maior que 2: ");
scanf("%f", &valor);
if(valor < 2) {
printf("ERRO. O valor introduzido deve ser maior que 2. Tente

Novamente.\n");
}else {
printf("O valor em questao e valido!\n", valor);
soma += valor;
i++;
}
media = soma / quantidade;
printf("A media dos valores definidos e: %.2f\n", media);
return 0;
3: Fibonacci
4: Verificar se é primo
#include <stdio.h>
#include <math.h>
int main (void) {
int i;
int valor;
int reposta;
int primo;
printf("Introduza um valor inteiro positivo: ");
if(valor < 0) {
printf("O valor definido e negativo, defina um valor inteiro positivo: ");
} else {
printf("O valor introduzido e valido!\n");
primo = valor / valor;
if(primo = 1) {
printf("O valor introduzido %d e um numero primo!",valor);
} else {
printf("O valor introduzido %d nao e um numero primo.", valor);
return 0;
5: Construir uma matriz quadrada com um valor sempre a mais
#include <stdio.h>
int main() {
int N, i, j;
do {
printf("Insira um valor inteiro N maior ou igual a 2: ");
scanf("%d", &N);
if (N < 2) {
printf("Por favor, insira um valor maior ou igual a 2.\n");
} while (N < 2);
i = 1;
while (i <= N) {
j = 1;
while (j <= N) {
printf("%2d ", i + j - 1);
++j;
printf("\n");
++i;
return 0;
6: pirâmide
#include <stdio.h>
int main (void) {
int coluna;
int i, j, k, l;
do {
printf("Introduza um valor maior ou igual a 2 para a coluna principal da

piramide: ");
scanf("%d", &coluna);
if(coluna < 2) {
printf("Numero invalido! Por favor, introduza um valor maior ou igual a

2: ");
scanf("%d", &coluna);
} while ( coluna < 2);
i = 1;
while (i <= coluna) {
j = 1;
while (j <= coluna - i) {
printf(" ");
j++;
k = 1;
while (k <= i) {
printf("%2d", k);
k++;
l = i - 1;
while (l >= 1) {
printf("%2d", l);
--l;
printf("\n");
++i;
return 0;
7; verificar se é capicua
#include <stdio.h>
int main (void) {
int valor;
int digito;
int original;
int inverso;
printf("Introduza um valor para verificar se ele e capicua: "); //valor pedido ao
utilizador
scanf("%d", &valor); // leitura do valor introduzido
original = valor;
while (valor > 0) { //operador para construir o inverso do valor dado
digito = valor % 10;
inverso = inverso * 10 + digito; // equações para montar o valor inverso
valor /= 10;
if (original == inverso) {
printf("O valor %d e capicua!", original); //resultado
} else {
printf("O valor %d nao e capicua.", original);
return 0;
Ficha 5
1: Função para ler e escrever vetor
#include <stdio.h>
void LerVector (float[], int);
void EscreverVector (float[], int);

int main (void) {
int dimensao;
float vetor[dimensao];
printf("Introduza um valor para a dimensao dos vetores: ");
scanf("%d", &dimensao);
if(dimensao < 1) {
printf("ERRO! Introduza um valor inteiro positivo: ");
LerVector(vetor, dimensao);
printf("Os valores do vetor e : \n");
EscreverVector(vetor, dimensao);
return 0; }
void LerVector (float vetor[], int dimensao) {
printf("Digita %d valores para o vetor: ", dimensao);
for (int i = 0; i < dimensao; i++) {
printf("vetor[%d]: ", i);
scanf("%f", &vetor[i]);
void EscreverVector (float vetor[], int dimensao) {
for (int i = 0; i < dimensao; i++){
printf("%.2f", vetor[i]);
}
printf("\n");
3: Função para Ler e Somar Vetor
#include <stdio.h>
void LerVector(int[], int);
int SomaElementosVector(int[], int);
int main(void) {
int dimensao;
int vetor[100];
int soma;
printf("Introduza um valor para a dimensao do vetor: ");
if (dimensao < 1) {
printf("ERRO! O valor introduzido nao e valido, defina um novo valor inteiro maior que 1:
");
soma = SomaElementosVector(vetor, dimensao);
printf("A soma dos elementos do vetor e: %d\n", soma);
return 0;
}
void LerVector(int vetor[], int dimensao) {
printf("Digite os valores do vetor: ");
scanf("%d", &vetor[i]);
int SomaElementosVector(int vetor[], int dimensao) {
int soma = 0;
soma += vetor[i];
return soma;
4: Função para ler vetor e verificar o elemnto máximo e mínimo
#include <stdio.h>
void LerVector(int[], int);
int MaximoElementoVector(int[], int);
int MinimoElementoVector(int[], int);
int main (void) {
int dimensao;
int maximo;
int minimo;
int vetor[100];
printf("Introduza um valor inteiro positivo maior que 1 para a dimensao do vetor: ");
if(dimensao < 1) {
printf("ERRO! O valor introduzido e invalido, defina um novo valor: ");
maximo = MaximoElementoVector(vetor, dimensao);
minimo = MinimoElementoVector(vetor, dimensao);
printf("O maximo elemento do vetor e %d e o minimo e %d", maximo, minimo);
return 0;
void LerVector(int vetor[100], int dimensao) {
printf("Introduza os valores do vetor: ");
for(int i = 0; i < dimensao; i++) {
printf("vetor[%d]", i);
scanf("%d", &vetor[i]); }
int MaximoElementoVector(int vetor[100], int dimensao){
int maximo = vetor[0];
if(vetor[i] > maximo) {
maximo = vetor[i];
}
return maximo;
int MinimoElementoVector(int vetor[100], int dimensao) {
int minimo = vetor[0];
if(vetor[i] < minimo) {
minimo = vetor[i];
return minimo;
5: Função para ler o vetor e dizer em qual posição se encontra o máximo e o mínimo
#include <stdio.h>
void LerVector (int [], int);
int PosicaoMaximoVector(int[], int);
int PosicaoMinimoVector(int[], int);
int main (void) {
int dimensao;
int PosicaoMaximo;
int PosicaoMinimo;
int vetor[100];
printf("Introduza o valor da dimensao do vetor (inteiro maior que 1): ");
if(dimensao < 1) {
printf("ERRO! O valor definido e invalido. Introduza um novo valor: ");
LerVector (vetor, dimensao);
PosicaoMaximo = PosicaoMaximoVector(vetor, dimensao);
PosicaoMinimo = PosicaoMinimoVector(vetor, dimensao);
printf("A posicao maxima do vetor e %d e a posicao minima do vetor e %d",

PosicaoMaximo, PosicaoMinimo);
return 0;
void LerVector (int vetor[100], int dimensao) {
printf("Introduza os valores do vetor: ");
printf("vetor[%d]", i);
scanf("%d", &vetor[i]); }
int PosicaoMaximoVector(int vetor[100], int dimensao){
int PosicaoMaximo = 0;

if(vetor[i] > vetor [PosicaoMaximo] ) {
PosicaoMaximo = i;
return PosicaoMaximo;
int PosicaoMinimoVector(int vetor[100], int dimensao) {
int PosicaoMinimo = 0;
if(vetor[i] < vetor[PosicaoMinimo]) {
PosicaoMinimo = i;
return PosicaoMinimo;
6: ler e somar vetores
#include <stdio.h>
void LerVector(float[], int);
void SomaVectores(float[], float[], float[], int);
int main(void) {
float soma;
int dimensao;
float vetor1[dimensao];
float vetor2[dimensao];
float resultado[dimensao];
printf("Introduza o valor da dimensao dos vetores: ");
if (dimensao < 1) {
printf("O valor inserido nao e valido. Digite um novo valor: ");
LerVector(vetor1, dimensao);
printf("Introduza os valores reais do vetor1:\n");
printf("vetor1[%d]: ", i);
scanf("%f", &vetor1[i]);
SomaVectores(vetor1, vetor2, resultado, dimensao);
printf("A soma dos vetores dados é:\n");
printf("%.2f ", resultado[i]);
return 0;
void LerVector(float vetor[], int dimensao) {

printf("Introduza os valores do vetor2:\n");
printf("vetor2[%d]: ", i);
void SomaVectores(float vetor1[], float vetor2[], float resultado[], int dimensao) {
resultado[i] = vetor1[i] + vetor2[i];
7; ler vetor e calcular a média aritmética
#include <stdio.h>
void LerVector(float[], int);
float MediaElementosVector(float[], int);
int main (void) {
int dimensao;
float media;
float vetor[dimensao];
printf("Introduza o valor da dimensao do vetor (maior que 1 e inteiro): ");
if(dimensao < 1) {
printf("ERRO. Digite um novo valor: ");
media = MediaElementosVector(vetor, dimensao);
printf("A media dos elementos do vetor e: %f\n", media);
return 0;
void LerVector(float vetor[], int dimensao) {
printf("Introduza os valores do vetor:\n");
float MediaElementosVector(float vetor[], int dimensao) {
float soma = 0.0;
soma += vetor[i];
return soma / dimensao;
8; matriz com dimensões e função de ler e escrever a matriz
#include <stdio.h>
const int NumLinhas = 3;
const int NumColunas = 3;
void LerMatriz(float[][NumColunas], int, int);
void EscreveMatriz(float[][NumColunas], int, int);
int main(void) {
int linhas;
int colunas;
printf("Introduza o numero de linhas da matriz: ");
scanf("%d", &linhas);
printf("Introduza o numero de colunas da matriz: ");
scanf("%d", &colunas);
if (linhas < 2 || colunas < 2) {
printf("Por favor, introduza valores maior ou igual a 2 para a quantidade de linhas ou

colunas: ");
scanf("%d%d", &linhas, &colunas);
float matriz[NumLinhas][NumColunas];
LerMatriz(matriz, linhas, colunas);
EscreveMatriz(matriz, linhas, colunas);
return 0;
void LerMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas) {

printf("Introduza os elementos da matriz:\n");
for (int i = 0; i < linhas; i++) {
for (int j = 0; j < colunas; j++) {
printf("Elemento [%d][%d]: ", i, j);
scanf("%f", &matriz[i][j]);
void EscreveMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas) {
printf("\nMatriz informada:\n");
printf("%.2f\t", matriz[i][j]);
printf("\n");
9; matriz com dimensões e com funções de ler, escrever e somar os elementos
#include <stdio.h>
void EscreveMatriz(float[][NumColunas], int, int);
float SomaElementosMatriz(float[][NumColunas], int, int);

int main (void) {
int linhas;
int colunas;
float soma;
printf("Introduza o numero de linhas da matriz entre 2 e 4: ");
if(linhas < 2 || linhas > 4){
printf("Valor Invalido. Digite um novo valor para o numero de linhas entre 2 e

4: ");
printf("Introduza o numero de colunas da matriz entre 2 e 4: ");
if(colunas < 2 || colunas > 4) {
printf("Valor invalido. Digite um novo valor para o numero de colunas entre 2 e

4: ");
EscreveMatriz(matriz, linhas, colunas);
soma = SomaElementosMatriz(matriz, linhas, colunas);
printf("A soma dos elementos da matriz e: %.2f", soma);
return 0;
}
printf("Introduza os elementos da matriz:\n");
void EscreveMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas) {
printf("\n");
float SomaElementosMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas) {
float soma = 0.0;
soma += matriz[i][j];
}
}
return soma;
10; máximo e elemento mínimo de uma matriz
#include <stdio.h>
void EscreverMatriz(float[][NumColunas], int, int);
float MaximoElementoMatriz(float[][NumColunas], int, int);
float MinimoElementoMatriz(float[][NumColunas], int, int);
int main (void) {
int linhas;
int colunas;
float maximo;
float minimo;
printf("Introduza o numero de linhas da matriz entre 2 e 4: ");
if(linhas < 2 || linhas > 4){
printf("Valor Invalido. Digite um novo valor para o numero de linhas entre 2 e

4: ");
}
printf("Introduza o numero de colunas da matriz entre 2 e 4: ");
if(colunas < 2 || colunas > 4) {
printf("Valor invalido. Digite um novo valor para o numero de colunas entre 2 e

4: ");
EscreverMatriz(matriz, linhas, colunas);
maximo = MaximoElementoMatriz(matriz, linhas, colunas);
minimo = MinimoElementoMatriz(matriz, linhas, colunas);
printf("O maior elemnto da matriz e %.2f e o menor e %.2f", maximo, minimo);
return 0;
void LerMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas){
printf("Introduza os elementos [i][j] da matriz: ");
for(int i = 0; i < linhas; i++){
for(int j = 0; j < colunas; j++){
printf("Elemento[%d][%d]", i, j);
void EscreverMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas) {

printf("\n");
float MaximoElementoMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas) {
float maximo = matriz[0][0];
if(matriz[i][j] > maximo){
maximo = matriz[i][j];
return maximo;
float MinimoElementoMatriz (float matriz[NumLinhas][NumColunas], int linhas, int colunas){
float minimo = matriz[0][0];
if(matriz[i][j] < minimo){
minimo = matriz [i][j];
}
return minimo;
11; posição dos máximos e mínimos de uma matriz
#include <stdio.h>
void EscreverMatriz(float[][NumColunas], int, int);
void PosicaoMaximoMatriz(float[][NumColunas], int, int, float*, int*, int*);
void PosicaoMinimoMatriz(float[][NumColunas], int, int, float*, int*, int*);
int main(void) {
int linhas;
int colunas;
float maximo;
float minimo;
int posicaoMaximo[2]; // [0] representa a linha, [1] representa a coluna
int posicaoMinimo[2]; // [0] representa a linha, [1] representa a coluna
printf("Introduza o numero de linhas da matriz: ");
printf("Introduza o numero de colunas da matriz: ");
float matriz[linhas][colunas];
EscreverMatriz(matriz, linhas, colunas);
PosicaoMaximoMatriz(matriz, linhas, colunas, &maximo, posicaoMaximo, posicaoMaximo);
PosicaoMinimoMatriz(matriz, linhas, colunas, &minimo, posicaoMinimo, posicaoMinimo);
printf("O maior elemento %.2f está na posição [%d][%d]\n", maximo, posicaoMaximo[0],

posicaoMaximo[1]);
printf("O menor elemento %.2f está na posição [%d][%d]\n", minimo, posicaoMinimo[0],

posicaoMinimo[1]);
return 0;
printf("Introduza os elementos [i][j] da matriz: ");
printf("Elemento[%d][%d]: ", i, j);
void EscreverMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas) {
printf("\n");
}
void PosicaoMaximoMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas, float
*maximo, int *posicaoLinha, int *posicaoColuna) {
*maximo = matriz[0][0];
posicaoLinha[0] = 0;
posicaoColuna[0] = 0;
if (matriz[i][j] > *maximo) {
*maximo = matriz[i][j];
posicaoLinha[0] = i;
posicaoColuna[0] = j;
void PosicaoMinimoMatriz(float matriz[NumLinhas][NumColunas], int linhas, int colunas, float

*minimo, int *posicaoLinha, int *posicaoColuna) {
*minimo = matriz[0][0];
posicaoLinha[0] = 0;
posicaoColuna[0] = 0;
if (matriz[i][j] < *minimo) {
*minimo = matriz[i][j];
posicaoLinha[0] = i;
posicaoColuna[0] = j;
}
}
12; elementos nulos da diagonal principal de uma matriz
#include <stdio.h>
int contarNulosDiagonalPrincipal(int matriz[10][10], int tamanho);
int main() {
int tamanho;
printf("Digite o tamanho da matriz (<= 10): ");
scanf("%d", &tamanho);
if (tamanho <= 0 || tamanho > 10) {
printf("Tamanho inválido. Escreva uma matriz com linhas e colunas menor que 10 \n");
return 1;
int matriz[10][10];
printf("Digite os elementos da matriz (%dx%d):\n", tamanho, tamanho);
for (int i = 0; i < tamanho; i++) {
for (int j = 0; j < tamanho; j++) {
scanf("%d", &matriz[i][j]);
}
int nulos = contarNulosDiagonalPrincipal(matriz, tamanho);
printf("O numero de elementos nulos na diagonal principal: %d\n", nulos);
return 0;
int contarNulosDiagonalPrincipal(int matriz[10][10], int tamanho) {
int nulos = 0;
for (int i = 0; i < tamanho; i++) {
if (matriz[i][i] == 0) {
nulos++;
return nulos;
13; ler duas matrizes e calcular o produto
#include <stdio.h>
void lerMatriz(float matriz[10][10], int linhas, int colunas);
void multiplicarMatrizes(float matriz1[10][10], float matriz2[10][10], float resultado[10][10], int

linhas1, int colunas1, int linhas2, int colunas2);
void imprimirMatriz(float matriz[10][10], int linhas, int colunas);

int main() {
int linhas1, colunas1, linhas2, colunas2;
printf("Digite o numero de linhas da primeira matriz: ");
scanf("%d", &linhas1);
printf("Digite o numero de colunas da primeira matriz: ");
scanf("%d", &colunas1);
printf("Digite o numero de linhas da segunda matriz: ");
scanf("%d", &linhas2);
printf("Digite o numero de colunas da segunda matriz: ");
scanf("%d", &colunas2);
if (colunas1 != linhas2) {
printf("As matrizes nao podem ser multiplicadas. O numero de colunas da primeira matriz
deve ser igual ao numero de linhas da segunda matriz.\n");
return 1;
float matriz1[10][10];
float matriz2[10][10];
float resultado[10][10];
printf("Digite os elementos da primeira matriz (%dx%d):\n", linhas1, colunas1);
lerMatriz(matriz1, linhas1, colunas1);
printf("Digite os elementos da segunda matriz (%dx%d)\n", linhas2, colunas2);
lerMatriz(matriz2, linhas2, colunas2);
multiplicarMatrizes(matriz1, matriz2, resultado, linhas1, colunas1, linhas2, colunas2);

printf("O produto das matrizes dada resutou em uma matriz (%dx%d):\n", linhas1, colunas2);
imprimirMatriz(resultado, linhas1, colunas2);
return 0;
void lerMatriz(float matriz[10][10], int linhas, int colunas) {
void multiplicarMatrizes(float matriz1[10][10], float matriz2[10][10], float resultado[10][10], int

linhas1, int colunas1, int linhas2, int colunas2) {
for (int i = 0; i < linhas1; i++) {
for (int j = 0; j < colunas2; j++) {
resultado[i][j] = 0;
for (int k = 0; k < colunas1; k++) {
resultado[i][j] += matriz1[i][k] * matriz2[k][j];
void imprimirMatriz(float matriz[10][10], int linhas, int colunas) {

printf("\n");
14; calcular a linha com maior soma
#include <stdio.h>
int encontrarLinhaMaxima(float matriz[10][10], int linhas, int colunas);
int main() {
int linhas, colunas;
printf("Digite o número de linhas da matriz: ");
printf("Digite o número de colunas da matriz: ");
if (linhas <= 0 || colunas <= 0 || linhas > 10 || colunas > 10) {
printf("Dimensões inválidas.\n");
return 1;
}
float matriz[10][10];
printf("Digite os elementos da matriz (%dx%d):\n", linhas, colunas);
lerMatriz(matriz, linhas, colunas);
// Chamar a função para encontrar a linha com a soma máxima
int linhaMaxima = encontrarLinhaMaxima(matriz, linhas, colunas);
// Exibir o resultado
printf("Linha com a soma máxima: %d\n", linhaMaxima);
return 0;
int encontrarLinhaMaxima(float matriz[10][10], int linhas, int colunas) {
int linhaMaxima = 0;
float somaMaxima = 0;

float somaLinha = 0;
somaLinha += matriz[i][j];
if (i == 0 || somaLinha > somaMaxima) {
somaMaxima = somaLinha;
linhaMaxima = i;
return linhaMaxima + 1; // Adiciona 1 para exibir linha começando do 1
printf("\n");
15; determinar a matriz transposta
#include <stdio.h>

void calcularTransposta(float matriz[10][10], float transposta[10][10], int linhas, int colunas);
int main() {
int linhas, colunas;
printf("Digite o numero de linhas da matriz: ");
printf("Digite o nu
mero de colunas da matriz: ");
if (linhas <= 0 || colunas <= 0 || linhas > 10 || colunas > 10) {
printf("ERRO! As dimensoes inseridas sao invalidas. Introduza valores entre 1 e 10");
return 1;
float matriz[10][10];
float transposta[10][10];
printf("Digite os elementos da matriz (%dx%d):\n", linhas, colunas);
lerMatriz(matriz, linhas, colunas);
calcularTransposta(matriz, transposta, linhas, colunas);

printf("Matriz Transposta (%dx%d):\n", colunas, linhas);
imprimirMatriz(transposta, colunas, linhas);
return 0;
void calcularTransposta(float matriz[10][10], float transposta[10][10], int linhas, int colunas) {
for (int i = 0; i < colunas; i++) {
for (int j = 0; j < linhas; j++) {
transposta[i][j] = matriz[j][i];
}
printf("\n");
Ficha 6
1; ler e escrever a string
#include <stdio.h>
int main() {
char string[100];
// Solicita ao usuário que insira uma string
printf("Digite uma string: ");
// Lê a string fornecida pelo usuário
fgets(string, sizeof(string), stdin);
// Imprime a string lida na tela
printf("A string digitada e: %s", string);
return 0;
2; função que recebe uma string e calcula o comprimento dela
#include <stdio.h>
#include <string.h>
int calcularComprimentoString(const char *str) {

int comprimento = 0;
int main() {
char string[100];
if (string[strlen(string) - 1] == '\n') {
string[strlen(string) - 1] = '\0';
printf("A string digitada e: %s\n", string);
int comprimento = calcularComprimentoString(string);
printf("O comprimento da string e: %d\n", comprimento);
return 0;
3; verificar se a string é uma letra e converter para maiscula

#include <stdio.h>
#include <ctype.h>
int main() {
char string[100];
// Converte cada letra para maiúscula
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i])) {
string[i] = toupper(string[i]);
// Imprime a string convertida na tela
printf("A string convertida é: %s", string);
return 0;
4; verificar se é uma substring
#include <stdio.h>
#include <string.h>
int main() {
char str1[100], str2[100];

// Solicita ao usuário que insira duas strings
printf("Digite a primeira string: ");
fgets(str1, sizeof(str1), stdin);
printf("Digite a segunda string: ");
fgets(str2, sizeof(str2), stdin);
// Remove o caractere de nova linha ('\n') do final das strings, se presente
if (str1[strlen(str1) - 1] == '\n') {
str1[strlen(str1) - 1] = '\0';
if (str2[strlen(str2) - 1] == '\n') {
str2[strlen(str2) - 1] = '\0';
// Verifica se str2 é substring de str1
if (strstr(str1, str2) != NULL) {
printf("\"%s\" e uma substring de \"%s\".\n", str2, str1);
} else {
printf("\"%s\" nao e uma substring de \"%s\".\n", str2, str1);
return 0;
5; inverter string através de uma função
#include <stdio.h>
#include <string.h>
// Função para inverter a string
void inverterString(char *str) {
int comprimento = strlen(str);
int inicio = 0;
int fim = comprimento - 1;
while (inicio < fim) {
// Troca os caracteres do início com os do fim
char temp = str[inicio];
str[inicio] = str[fim];
str[fim] = temp;
// Move os índices para o próximo par de caracteres
inicio++;
fim--;
int main() {
// Tamanho máximo da string
#define MAX_TAMANHO_STRING 100
char minhaString[MAX_TAMANHO_STRING];
// Lê a string do teclado
fgets(minhaString, MAX_TAMANHO_STRING, stdin);

// Remove o caractere de nova linha (\n) da string, se presente
int i = 0;
while (minhaString[i] != '\0' && minhaString[i] != '\n') {
i++;
minhaString[i] = '\0';
// Inverte a string
inverterString(minhaString);
// Exibe a string invertida na tela
printf("A string invertida é: %s\n", minhaString);
return 0;
6; função para calcular a quantidade de dígitos de uma string
#include <stdio.h>
#include <ctype.h>
// Função para calcular o número de dígitos na string
int calcularNumeroDigitos(const char *str) {
int numeroDigitos = 0;
for (int i = 0; str[i] != '\0'; i++) {
if (isdigit(str[i])) {
numeroDigitos++;
}
return numeroDigitos;
int main() {
int i = 0;
i++;
// Calcula o número de dígitos na string
int numeroDigitos = calcularNumeroDigitos(minhaString);
// Exibe o número de dígitos na string
printf("O número de dígitos na string é: %d\n", numeroDigitos);
return 0;
}
7; função para verificar se a string é capicua ou não
#include <stdio.h>
#include <string.h>
// Função para verificar se a string é um palíndromo (capicua)
int verificarCapicua(const char *str) {
int comprimento = strlen(str);
int inicio = 0;
int fim = comprimento - 1;
while (inicio < fim) {
if (str[inicio] != str[fim]) {
// Se os caracteres não são iguais, a string não é capicua
return 0;
inicio++;
fim--;
// Se a função chegou até aqui, a string é capicua
return 1;
int main() {

int i = 0;
i++;
// Verifica se a string é capicua
if (verificarCapicua(minhaString)) {
printf("A string é capicua.\n");
} else {
printf("A string não é capicua.\n");
return 0;
8; função para contar o numero de caracter na string
#include <stdio.h>
// Função para contar o número de ocorrências do caractere na string
int contarOcorrencias(const char *str, char caractere) {
int contador = 0;
for (int i = 0; str[i] != '\0'; i++) {

if (str[i] == caractere) {
contador++;
return contador;
int main() {
char caractere;
int i = 0;
i++;
// Solicita ao usuário que insira um caractere
printf("Digite um caractere: ");

// Lê o caractere do teclado
scanf(" %c", &caractere);
// Conta o número de ocorrências do caractere na string
int numeroOcorrencias = contarOcorrencias(minhaString, caractere);
// Exibe o resultado na tela
printf("O caractere '%c' ocorre %d vezes na string.\n", caractere, numeroOcorrencias);
return 0;
9; função para remover string do caracter
#include <stdio.h>
// Função para remover todas as ocorrências do caractere na string
void removerOcorrencias(char *str, char caractere) {
int i, j;
for (i = j = 0; str[i] != '\0'; i++) {
if (str[i] != caractere) {
str[j++] = str[i];
// Adiciona o caractere nulo ao final da nova string
str[j] = '\0';
int main() {
char caractere;
int i = 0;
i++;
// Solicita ao usuário que insira um caractere
printf("Digite um caractere: ");
// Lê o caractere do teclado
scanf(" %c", &caractere);
// Remove todas as ocorrências do caractere na string
removerOcorrencias(minhaString, caractere);
// Exibe a string alterada na tela
printf("String sem as ocorrencias do caractere '%c': %s\n", caractere, minhaString);

return 0;
Ficha 7
1; armazenar ponto no espaço tridimensional e funcçao para determinar a distancia
a) #include <stdio.h>
// Definição do tipo PONTO3D
typedef struct {
double x;
double y;
double z;
} PONTO3D;
// Função para ler um ponto de R3 (alternativa 1)
PONTO3D lerPONTO() {
PONTO3D ponto;
printf("Digite as coordenadas x, y e z separadas por espaços: ");
scanf("%lf %lf %lf", &ponto.x, &ponto.y, &ponto.z);
return ponto;
// Função para ler um ponto de R3 (alternativa 2)
void lerPONTO(PONTO3D* ponto) {
scanf("%lf %lf %lf", &ponto->x, &ponto->y, &ponto->z);
}
int main() {
PONTO3D ponto1, ponto2;
// Usando a primeira alternativa
ponto1 = lerPONTO();
// Usando a segunda alternativa
lerPONTO(&ponto2);
// Exibindo os pontos lidos
printf("Ponto 1: (%.2lf, %.2lf, %.2lf)\n", ponto1.x, ponto1.y, ponto1.z);
printf("Ponto 2: (%.2lf, %.2lf, %.2lf)\n", ponto2.x, ponto2.y, ponto2.z);
return 0;
b) #include <stdio.h>
#include <math.h>
typedef struct {
double x;
double y;
double z;
} PONTO3D;
// Função para escrever um ponto de R3
void escreverPONTO(PONTO3D ponto) {
printf("Ponto: (%.2lf, %.2lf, %.2lf)\n", ponto.x, ponto.y, ponto.z);
}
// Função para determinar a distância entre dois pontos de R3
float distanciaDoisPontos(PONTO3D ponto1, PONTO3D ponto2) {
double distancia = sqrt(pow(ponto2.x - ponto1.x, 2) + pow(ponto2.y - ponto1.y, 2) +

pow(ponto2.z - ponto1.z, 2));
return (float)distancia;
int main() {
PONTO3D ponto1, ponto2;
// Lendo dois pontos
printf("Digite as coordenadas do primeiro ponto (x y z): ");
scanf("%lf %lf %lf", &ponto1.x, &ponto1.y, &ponto1.z);
printf("Digite as coordenadas do segundo ponto (x y z): ");
scanf("%lf %lf %lf", &ponto2.x, &ponto2.y, &ponto2.z);
// Exibindo os pontos
printf("\nPontos Lidos:\n");
escreverPONTO(ponto1);
escreverPONTO(ponto2);
// Calculando e exibindo a distância entre os pontos
float dist = distanciaDoisPontos(ponto1, ponto2);
printf("\nDistancia entre os pontos: %.2f\n", dist);
return 0;
2; ler e calcular a soma de dois números complexos

#include <stdio.h>
// Definição do tipo COMPLEXO
typedef struct {
float a; /* parte real */
float b; /* parte imaginária */
} COMPLEXO;
// Função para ler um número complexo
COMPLEXO lerComplexo() {
COMPLEXO num;
printf("Digite a parte real e imaginaria do numero complexo (a b): ");
scanf("%f %f", &num.a, &num.b);
return num;
// Função para escrever um número complexo
void escreverComplexo(COMPLEXO num) {
printf("Numero Complexo: %.2f + %.2fi\n", num.a, num.b);
// Função para calcular a soma de dois números complexos
COMPLEXO somaComplexos(COMPLEXO num1, COMPLEXO num2) {
COMPLEXO resultado;
resultado.a = num1.a + num2.a;
resultado.b = num1.b + num2.b;
return resultado;
}
int main() {
COMPLEXO numero1, numero2, resultado;
// Lendo dois números complexos
printf("Digite o primeiro numero complexo:\n");
numero1 = lerComplexo();
printf("\nDigite o segundo numero complexo:\n");
numero2 = lerComplexo();
// Exibindo os números complexos
printf("\nNumeros Complexos Lidos:\n");
escreverComplexo(numero1);
escreverComplexo(numero2);
// Calculando a soma e exibindo o resultado
resultado = somaComplexos(numero1, numero2);
printf("\nSoma dos Numeros Complexos:\n");
escreverComplexo(resultado);
return 0;
3; funções equalentry e comefirst
#include <stdio.h>
#include <string.h>
#define MAX 25
// Definição da estrutura ESTUDANTE
typedef struct {
char nome[MAX];
char apelido[MAX];
char residencia[MAX];
int telefone;
} ESTUDANTE;
// Função para comparar se dois registros de estudantes são idênticos
int equalEntry(ESTUDANTE aluno1, ESTUDANTE aluno2) {
return (strcmp(aluno1.nome, aluno2.nome) == 0 &&
strcmp(aluno1.apelido, aluno2.apelido) == 0 &&
strcmp(aluno1.residencia, aluno2.residencia) == 0 &&
aluno1.telefone == aluno2.telefone);
// Função para determinar se o primeiro estudante vem antes do segundo alfabeticamente
int comesFirst(ESTUDANTE aluno1, ESTUDANTE aluno2) {
int nomeComparison = strcmp(aluno1.nome, aluno2.nome);
if (nomeComparison == 0) {
return strcmp(aluno1.apelido, aluno2.apelido) < 0;
} else {
return nomeComparison < 0;
int main() {
ESTUDANTE estudante1, estudante2;

// Leitura de dois registros de estudantes
printf("Digite os dados do primeiro estudante:\n");
printf("Nome: ");
fgets(estudante1.nome, MAX, stdin);
printf("Apelido: ");
fgets(estudante1.apelido, MAX, stdin);
printf("Residencia: ");
fgets(estudante1.residencia, MAX, stdin);
printf("Telefone: ");
scanf("%d", &estudante1.telefone);
getchar(); // Consumir o caractere de nova linha deixado pelo scanf
printf("\nDigite os dados do segundo estudante:\n");
printf("Nome: ");
fgets(estudante2.nome, MAX, stdin);
printf("Apelido: ");
fgets(estudante2.apelido, MAX, stdin);
printf("Residencia: ");
fgets(estudante2.residencia, MAX, stdin);
printf("Telefone: ");
scanf("%d", &estudante2.telefone);
// Verificação se os registros são idênticos
if (equalEntry(estudante1, estudante2)) {
printf("\nOs registros dos estudantes são idênticos.\n");
} else {
printf("\nOs registros dos estudantes não são idênticos.\n");
// Verificação de qual estudante vem primeiro alfabeticamente

if (comesFirst(estudante1, estudante2)) {
printf("O primeiro estudante vem primeiro alfabeticamente.\n");
} else {
printf("O segundo estudante vem primeiro alfabeticamente.\n");
return 0;
4; ponto mais pertos e mais distantes
#include <stdio.h>
#include <math.h>
typedef struct {
double x;
double y;
double z;
} PONTO3D;
// Função para calcular a distância entre dois pontos de R3
float distanciaDoisPontos(PONTO3D ponto1, PONTO3D ponto2) {
double distancia = sqrt(pow(ponto2.x - ponto1.x, 2) + pow(ponto2.y - ponto1.y, 2) +

pow(ponto2.z - ponto1.z, 2));
return (float)distancia;
// Função que determina os dois pontos mais próximos
void nearestPoints(PONTO3D *vp, PONTO3D *p, PONTO3D *q) {
float menorDistancia = distanciaDoisPontos(vp[0], vp[1]);

*p = vp[0];
*q = vp[1];
for (int i = 0; i < 3; ++i) {
for (int j = i + 1; j < 3; ++j) {
float dist = distanciaDoisPontos(vp[i], vp[j]);
if (dist < menorDistancia) {
menorDistancia = dist;
*p = vp[i];
*q = vp[j];
// Função que determina os dois pontos mais afastados
void farthestPoints(PONTO3D *vp, PONTO3D *p, PONTO3D *q) {
float maiorDistancia = distanciaDoisPontos(vp[0], vp[1]);
*p = vp[0];
*q = vp[1];
for (int i = 0; i < 3; ++i) {
for (int j = i + 1; j < 3; ++j) {
float dist = distanciaDoisPontos(vp[i], vp[j]);
if (dist > maiorDistancia) {
maiorDistancia = dist;
*p = vp[i];
*q = vp[j];
}
}
int main() {
PONTO3D pontos[3];
PONTO3D pontoMaisProximo1, pontoMaisProximo2, pontoMaisAfastado1,

pontoMaisAfastado2;
// Lendo os pontos
for (int i = 0; i < 3; ++i) {
printf("Digite as coordenadas do ponto %d (x y z): ", i + 1);
scanf("%lf %lf %lf", &pontos[i].x, &pontos[i].y, &pontos[i].z);
// Calculando os dois pontos mais próximos
nearestPoints(pontos, &pontoMaisProximo1, &pontoMaisProximo2);
// Calculando os dois pontos mais afastados
farthestPoints(pontos, &pontoMaisAfastado1, &pontoMaisAfastado2);
// Exibindo os resultados
printf("\nDois Pontos Mais Próximos:\n");
printf("Ponto 1: (%.2lf, %.2lf, %.2lf)\n", pontoMaisProximo1.x, pontoMaisProximo1.y,

pontoMaisProximo1.z);
printf("Ponto 2: (%.2lf, %.2lf, %.2lf)\n", pontoMaisProximo2.x, pontoMaisProximo2.y,

pontoMaisProximo2.z);
printf("\nDois Pontos Mais Afastados:\n");
printf("Ponto 1: (%.2lf, %.2lf, %.2lf)\n", pontoMaisAfastado1.x, pontoMaisAfastado1.y,

pontoMaisAfastado1.z);
printf("Ponto 2: (%.2lf, %.2lf, %.2lf)\n", pontoMaisAfastado2.x, pontoMaisAfastado2.y,

pontoMaisAfastado2.z);
return 0;
}
Ficha 8
1; ler frase e guardar em arquivo
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *arquivo;
char frase[1000];
// Abrindo o arquivo para escrita
arquivo = fopen("ficheiro.txt", "w");
// Verificando se o arquivo foi aberto com sucesso
if (arquivo == NULL) {
printf("Erro ao abrir o arquivo.\n");
return 1; // Saindo do programa com código de erro
// Lendo a frase do teclado
printf("Digite uma frase: ");
fgets(frase, sizeof(frase), stdin);
// Escrevendo a frase no arquivo
fprintf(arquivo, "%s", frase);
// Fechando o arquivo
fclose(arquivo);
printf("Frase escrita no arquivo 'ficheiro.txt'.\n");
return 0;
2; escrever o conteúdo do ficheiro no ecrã
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *arquivo;
char linha[1000];
// Abrindo o arquivo para leitura
arquivo = fopen("ficheiro.txt", "r");
// Lendo e exibindo o conteúdo do arquivo linha por linha
printf("Conteudo do arquivo 'ficheiro.txt':\n");
while (fgets(linha, sizeof(linha), arquivo) != NULL) {
printf("%s", linha);
fclose(arquivo);
return 0;
3; ler ficheiro, calcular o numero de alunos reprovados, calcular a média das notas dos alunos
reprovados
#include <stdio.h>
// Função para ler do arquivo um vetor de inteiros com as notas dos alunos
void LerVetor(int V[], int *N) {
FILE *arquivo;
int nota;
int i = 0;
arquivo = fopen("Alunos.txt", "r");
return;
while (fscanf(arquivo, "%d", &nota) == 1) {
V[i++] = nota;
*N = i;
fclose(arquivo);
}
// Função para calcular o número de alunos reprovados
int NumeroReprovados(int V[], int N) {
int contadorReprovados = 0;
for (int i = 0; i < N; ++i) {
if (V[i] < 10) {
contadorReprovados++;
return contadorReprovados;
// Função para calcular a média das notas dos alunos aprovados
float MediaNotasAprovados(int V[], int N) {
int somaNotas = 0;
int contadorAprovados = 0;
for (int i = 0; i < N; ++i) {
if (V[i] >= 10) {
somaNotas += V[i];
contadorAprovados++;
if (contadorAprovados > 0) {
return (float)somaNotas / contadorAprovados;
} else {
return 0.0; // Evita divisão por zero se não houver alunos aprovados
}
}
int main() {
int notas[100]; // Assumindo que há no máximo 100 alunos
int numAlunos;
LerVetor(notas, &numAlunos);
if (numAlunos > 0) {
printf("Numero de alunos reprovados: %d\n", NumeroReprovados(notas, numAlunos));
printf("Media das notas dos alunos aprovados: %.2f\n", MediaNotasAprovados(notas,

numAlunos));
} else {
printf("Nenhuma nota lida do arquivo.\n");
return 0;
4; função para ler um ponto 3d, escrever, calcular a distancia entre dois pontos e guardar num
ficheiro
#include <stdio.h>
#include <math.h>
typedef struct {
double x;
double y;
double z;
} PONTO3D;
// Função para ler um ponto de R3
void lerPonto(PONTO3D *ponto) {
scanf("%lf %lf %lf", &ponto->x, &ponto->y, &ponto->z);
// Função para escrever um ponto de R3
void escreverPonto(PONTO3D ponto) {
printf("Ponto: (%.2lf, %.2lf, %.2lf)\n", ponto.x, ponto.y, ponto.z);
// Função para determinar a distância entre dois pontos de R3
double distanciaDoisPontos(PONTO3D ponto1, PONTO3D ponto2) {
return sqrt(pow(ponto2.x - ponto1.x, 2) + pow(ponto2.y - ponto1.y, 2) + pow(ponto2.z -

ponto1.z, 2));
// Função para guardar o array de pontos de R3 em um arquivo de texto
void guardarPontosEmArquivo(PONTO3D pontos[], int numPontos, const char *nomeArquivo) {
FILE *arquivo = fopen(nomeArquivo, "w");
printf("Erro ao abrir o arquivo para escrita.\n");
return;
for (int i = 0; i < numPontos; ++i) {
fprintf(arquivo, "%.2lf %.2lf %.2lf\n", pontos[i].x, pontos[i].y, pontos[i].z);
fclose(arquivo);
}
// Função para ler os pontos de R3 de um arquivo de texto e guardá-los em um array
void lerPontosDeArquivo(PONTO3D pontos[], int *numPontos, const char *nomeArquivo) {
FILE *arquivo = fopen(nomeArquivo, "r");
printf("Erro ao abrir o arquivo para leitura.\n");
return;
*numPontos = 0;
while (fscanf(arquivo, "%lf %lf %lf", &pontos[*numPontos].x, &pontos[*numPontos].y,

&pontos[*numPontos].z) == 3) {
(*numPontos)++;
fclose(arquivo);
int main() {
int numPontos;
PONTO3D pontos[100]; // Assumindo que há no máximo 100 pontos
// Leitura da sequência de pontos
printf("Digite o número de pontos: ");
scanf("%d", &numPontos);
lerPonto(&pontos[i]);
}
// Exibindo os pontos
printf("\nPontos lidos:\n");
escreverPonto(pontos[i]);
// Calculando a distância entre dois pontos
if (numPontos >= 2) {
double dist = distanciaDoisPontos(pontos[0], pontos[1]);
printf("\nDistancia entre os dois primeiros pontos: %.2lf\n", dist);
} else {
printf("\nNao ha pontos suficientes para calcular a distancia.\n");
// Salvando os pontos em um arquivo
guardarPontosEmArquivo(pontos, numPontos, "pontos.txt");
printf("\nPontos salvos no arquivo 'pontos.txt'.\n");
// Lendo pontos de um arquivo
int numPontosLidos;
PONTO3D pontosLidos[100]; // Assumindo que há no máximo 100 pontos
lerPontosDeArquivo(pontosLidos, &numPontosLidos, "pontos.txt");
// Exibindo os pontos lidos do arquivo
printf("\nPontos lidos do arquivo 'pontos.txt':\n");
for (int i = 0; i < numPontosLidos; ++i) {
escreverPonto(pontosLidos[i]);
}
return 0;
5; ler frase e escrever num arquivo binário
#include <stdio.h>
#include <string.h>
int main() {
FILE *arquivo;
char frase[1000];
// Abrindo o arquivo para escrita binária
arquivo = fopen("ficheiro.dat", "wb");
// Lendo a frase do teclado
printf("Digite uma frase: ");
fgets(frase, sizeof(frase), stdin);
// Removendo o caractere de nova linha se estiver presente
size_t comprimento = strlen(frase);
if (comprimento > 0 && frase[comprimento - 1] == '\n') {
frase[comprimento - 1] = '\0';
}
// Escrevendo a frase no arquivo binário
fwrite(frase, sizeof(char), strlen(frase), arquivo);
fclose(arquivo);
printf("Frase escrita no arquivo 'ficheiro.dat'.\n");
return 0;
6; escrever na tela os arquivos do ficheiro
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *arquivo;
char frase[1000];
// Abrindo o arquivo para leitura binária
arquivo = fopen("ficheiro.dat", "rb");
// Lendo o conteúdo do arquivo binário

size_t bytesRead = fread(frase, sizeof(char), sizeof(frase), arquivo);
fclose(arquivo);
// Verificando se a leitura foi bem-sucedida
if (bytesRead > 0) {
// Exibindo o conteúdo lido no console
printf("Conteudo do arquivo 'ficheiro.dat':\n");
fwrite(frase, sizeof(char), bytesRead, stdout);
printf("\n");
} else {
printf("Erro ao ler o conteudo do arquivo.\n");
return 0;

Todas As Fichas Resolvidas

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Todas As Fichas Resolvidas

Enviado por

Direitos autorais:

Formatos disponíveis

Ficha 1

int main (void) {

printf("Introduza um valor inteiro para a: ");

printf("Introduza um valor inteiro para b: ");

printf("A soma dos valores dados e %d e a diferenca e %d", soma, diferenca);

2: Produto entre inteiro e real

printf("Introduza um valor inteiro para a: ");

printf("Introduza um valor real para b: ");

printf("O valor do produto entre os alores e: %f", produto);

int main (void) {

printf("Introduza um valor para a base do retangulo: ");

printf("Introduza um valor para a altura do retandulo: ");

area = base * altura;

printf("O valor da area do retangulo e: %f", area);

int main (void) {

printf("Introduza o preço do produto: ");

printf("Introduza o valor da taxa IVA: ");

total = preco * taxa;

printf("O valor do produto com imposto aplicado e %f", total);

5: media das notas

int main (void) {

printf("Introduza a nota da primeira discilplina (inteiros): ");

printf("Introduza a nota da segunda disciplina: ");

printf("A media das notas e %f", nota);

printf("Introduza a massa em Kg: ");

printf("O valor do quilo em gramas e de %f", gramas);

7: Converter graus C para F

int main (void) {

printf("Introduza o valor da temperatura em graus celsius: ");

8: horas, minutos e segundos

int main (void) {

printf("Introduza um valor inteiro em segundos: ");

horas = segundos / 3600;

minutos = (segundos / 3600) / 60;

printf(" O horario e %d:%d:%d", horas, minutos, segundos);

int main (){

printf("introduza um numero inteiro:");

printf("Introduza um valor inteiro: ");

printf("O numero %d e par", numero);

printf("O numero %d e impar", numero);

2: Comparar 3 valores e verificar qual é o maior

printf("Introduza tres valores inteiros: ");

scanf("%d%d%d", &a, &b, &c);

if(a>b && a>c)

printf("%d e o maior valor", a);

if(b>a && b>c)

printf("%d e o maior valor", b);

if(c>a && c>b)

printf("%d e o maior valor", c);

3: resto da divisão do maior inteiro pelo menor

printf("Introoduza dois valores inteiros: ");

scanf("%d%d", &a, &b);

printf("O resto da divisao de %d sobre %d e %f", a, b, resto);

printf("O resto da divisao de %d sobre %d e %f", b, a, resto);

4: Verificar se o inteiro e divisível por 3

int main (void) {

printf("Introduza um valor inteiro: ");

printf("O valor %d e divisivel por 3!",a);

printf("%d nao e divisel por 3", a);

5: calcular o valor de x da função dada

6: imposto a pagar pelo ordenado

printf("Introduza o valor do ordenado anual: ");

if(ordenado <= 8.000) {