#include <stdio.h>
#include <math.h>

#define MAX_PONTOS 100

typedef struct {
    float x;
    float y;
} Ponto;

// Protótipo
float distancia(Ponto a, Ponto b);

int main() {
    Ponto pontos[MAX_PONTOS];
    int n, i, j;
    float maiorDistancia = 0, d;

    printf("Quantidade de pontos (2 a 100): ");
    scanf("%d", &n);
    while (n < 2 || n > 100) {
        printf("Valor invalido! Digite novamente (2 a 100): ");
        scanf("%d", &n);
    }

    for (i = 0; i < n; i++) {
        printf("Ponto %d - x: ", i);
        scanf("%f", &pontos[i].x);
        printf("Ponto %d - y: ", i);
        scanf("%f", &pontos[i].y);
    }

    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            d = distancia(pontos[i], pontos[j]);
            if (d > maiorDistancia) {
                maiorDistancia = d;
            }
        }
    }

    printf("Maior distancia entre dois pontos: %.2f\n", maiorDistancia);

    return 0;
}

// Implementação
float distancia(Ponto a, Ponto b) {
    float dx = a.x - b.x;
    float dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
}

A validação de n usa um while (Aula 3) porque não sabemos de antemão quantas vezes o usuário vai errar. distancia recebe as duas structs por valor — como só precisamos ler as coordenadas, não há necessidade de ponteiros aqui.

#include <stdio.h>

typedef struct {
    char nome[80];
    char sexo;
    float salario;
} Funcionario;

// Protótipo
int atualiza(Funcionario *f, float referencia);

int main() {
    float referencia;
    Funcionario f;
    FILE *bin, *txt;

    printf("Salario de referencia: ");
    scanf("%f", &referencia);

    bin = fopen("func.bin", "rb");
    if (bin == NULL) {
        return 1;
    }

    txt = fopen("func.txt", "w");
    if (txt == NULL) {
        fclose(bin);
        return 1;
    }

    while (fread(&f, sizeof(Funcionario), 1, bin) == 1) {
        if (atualiza(&f, referencia)) {
            fprintf(txt, "%s,%.2f\n", f.nome, f.salario);
        }
    }

    fclose(bin);
    fclose(txt);
    return 0;
}

// Implementação
int atualiza(Funcionario *f, float referencia) {
    if (f->salario < referencia) {
        f->salario = referencia;
        return 1;
    }
    return 0;
}

Como a quantidade de funcionários no arquivo é desconhecida, usamos o próprio retorno de fread como condição do while (Aula 11): o laço só continua enquanto conseguirmos ler exatamente 1 struct por vez. atualiza recebe um ponteiro porque precisa alterar de fato o salário do funcionário (Aula 9), e seu retorno (0 ou 1) decide se aquele funcionário é gravado em "func.txt".

#include <stdio.h>

typedef struct {
    char nome[100];
    char classe;
    float preco;
} Produto;

int main() {
    char classeDesejada;
    Produto p;
    FILE *bin, *txt;

    printf("Classe de interesse (A, B ou C): ");
    scanf(" %c", &classeDesejada);

    bin = fopen("prod.bin", "rb");
    if (bin == NULL) {
        return 1;
    }

    txt = fopen("prod.txt", "w");
    if (txt == NULL) {
        fclose(bin);
        return 1;
    }

    while (fread(&p, sizeof(Produto), 1, bin) == 1) {
        if (p.classe == classeDesejada) {
            fprintf(txt, "%s,%.2f\n", p.nome, p.preco);
        }
    }

    fclose(bin);
    fclose(txt);
    return 0;
}

O espaço antes de %c em scanf(" %c", &classeDesejada) descarta espaços/quebras de linha deixados no buffer, evitando que a leitura do caractere pegue um '\n' por engano — um cuidado importante ao misturar %d/%f com %c no scanf.

#include <stdio.h>
#include <string.h>

#define MAX_JOGOS 100

typedef struct {
    int id;
    char nome[100];
} Jogo;

// Protótipos (assinaturas exigidas pelo enunciado)
int lerJogosTexto(const char *nomeArquivo, Jogo jogos[], int maxJogos);
void escreverJogosBinario(const char *nomeArquivo, Jogo jogos[], int quantidade);
void exibirJogosBinario(const char *nomeArquivo);

int main() {
    Jogo jogos[MAX_JOGOS];
    int quantidade;

    // 1) Le do arquivo texto
    quantidade = lerJogosTexto("jogos.txt", jogos, MAX_JOGOS);

    // 2) Grava no arquivo binario
    escreverJogosBinario("jogos.bin", jogos, quantidade);

    // 3) Exibe o que foi gravado, lendo de volta do binario
    exibirJogosBinario("jogos.bin");

    return 0;
}

// Le "id;nome" por linha, ate o fim do arquivo ou ate maxJogos
int lerJogosTexto(const char *nomeArquivo, Jogo jogos[], int maxJogos) {
    FILE *arquivo = fopen(nomeArquivo, "r");
    int quantidade = 0;

    if (arquivo == NULL) {
        return 0;
    }

    while (quantidade < maxJogos &&
           fscanf(arquivo, "%d;%99[^\n]\n", &jogos[quantidade].id, jogos[quantidade].nome) == 2) {
        quantidade++;
    }

    fclose(arquivo);
    return quantidade;
}

// Grava o vetor inteiro de uma vez, em modo binario
void escreverJogosBinario(const char *nomeArquivo, Jogo jogos[], int quantidade) {
    FILE *arquivo = fopen(nomeArquivo, "wb");
    if (arquivo == NULL) {
        return;
    }

    fwrite(jogos, sizeof(Jogo), quantidade, arquivo);
    fclose(arquivo);
}

// Le do binario, um Jogo por vez, e exibe no console
void exibirJogosBinario(const char *nomeArquivo) {
    FILE *arquivo = fopen(nomeArquivo, "rb");
    Jogo j;

    if (arquivo == NULL) {
        return;
    }

    printf("Jogos cadastrados:\n");
    while (fread(&j, sizeof(Jogo), 1, arquivo) == 1) {
        printf("%d - %s\n", j.id, j.nome);
    }

    fclose(arquivo);
}

O formato de leitura "%d;%99[^\n]\n" lê um inteiro, pula o ; literal, e captura o restante da linha (até \n, no máximo 99 caracteres) como o nome — uma forma de ler campos separados por um caractere que não seja espaço, algo que %s sozinho não conseguiria fazer (pois %s para no primeiro espaço).

#include <stdio.h>

#define NUM_ESTUDANTES 3

typedef struct {
    char nome[50];
    int matricula;
    float notas[3];
    float media;
} Estudante;

// Protótipos
void cadastrarEstudante(Estudante *estudante);
void imprimirEstudante(Estudante estudante);
float calcularMedia(float notas[3]);
Estudante melhorAluno(Estudante estudantes[], int quantidade);

int main() {
    Estudante turma[NUM_ESTUDANTES];
    int i;

    for (i = 0; i < NUM_ESTUDANTES; i++) {
        printf("--- Estudante %d ---\n", i + 1);
        cadastrarEstudante(&turma[i]);
    }

    printf("\nTodos os estudantes:\n");
    for (i = 0; i < NUM_ESTUDANTES; i++) {
        imprimirEstudante(turma[i]);
    }

    printf("\nMelhor aluno:\n");
    imprimirEstudante(melhorAluno(turma, NUM_ESTUDANTES));

    return 0;
}

// Implementações
void cadastrarEstudante(Estudante *estudante) {
    int i;

    printf("Nome: ");
    scanf("%s", estudante->nome);
    printf("Matricula: ");
    scanf("%d", &estudante->matricula);

    for (i = 0; i < 3; i++) {
        printf("Nota %d: ", i + 1);
        scanf("%f", &estudante->notas[i]);
    }

    estudante->media = calcularMedia(estudante->notas);
}

void imprimirEstudante(Estudante estudante) {
    printf("%s (matricula %d) - notas: %.1f, %.1f, %.1f - media: %.2f\n",
           estudante.nome, estudante.matricula,
           estudante.notas[0], estudante.notas[1], estudante.notas[2],
           estudante.media);
}

float calcularMedia(float notas[3]) {
    return (notas[0] + notas[1] + notas[2]) / 3;
}

Estudante melhorAluno(Estudante estudantes[], int quantidade) {
    int i;
    Estudante melhor = estudantes[0];

    for (i = 1; i < quantidade; i++) {
        if (estudantes[i].media > melhor.media) {
            melhor = estudantes[i];
        }
    }

    return melhor;
}

Note as três formas de passagem em ação: cadastrarEstudante recebe ponteiro (precisa alterar o estudante de quem chamou); imprimirEstudante recebe por valor (só precisa ler); e melhorAluno retorna uma struct inteira (uma cópia do melhor estudante encontrado).

#include <stdio.h>

#define MAX_ALUNOS 10

typedef struct {
    char nome[50];
    float nota;
} Aluno;

// Protótipos
void inicializarAlunos(Aluno *lista, int tamanho);
void alterarNota(Aluno *aluno, float novaNota);
Aluno melhorAluno(Aluno alunos[], int tamanho);

int main() {
    Aluno alunos[MAX_ALUNOS];

    inicializarAlunos(alunos, MAX_ALUNOS);

    alterarNota(&alunos[2], 9.5); // terceiro aluno = indice 2

    printf("Melhor aluno: %s\n", melhorAluno(alunos, MAX_ALUNOS).nome);

    return 0;
}

// Implementações
void inicializarAlunos(Aluno *lista, int tamanho) {
    int i;

    for (i = 0; i < tamanho; i++) {
        printf("Nome do aluno %d: ", i + 1);
        scanf("%s", lista[i].nome);
        printf("Nota do aluno %d: ", i + 1);
        scanf("%f", &lista[i].nota);
    }
}

void alterarNota(Aluno *aluno, float novaNota) {
    aluno->nota = novaNota;
}

Aluno melhorAluno(Aluno alunos[], int tamanho) {
    int i;
    Aluno melhor = alunos[0];

    for (i = 1; i < tamanho; i++) {
        if (alunos[i].nota > melhor.nota) {
            melhor = alunos[i];
        }
    }

    return melhor;
}

Repare como &alunos[2] obtém o endereço de uma posição específica do vetor — combinando o que vimos sobre vetores (Aula 4) e sobre & (Aula 9) — permitindo que alterarNota altere exatamente aquele aluno, e nenhum outro.

#include <stdio.h>

typedef struct {
    int id;
    float temperatura;
} Sensor;

// (b) Le "id leitura" por linha, ate o fim do arquivo
int carregarSensoresTexto(char nomeArquivo[], Sensor sensores[], int *tamanho) {
    FILE *arquivo = fopen(nomeArquivo, "r");

    if (arquivo == NULL) {
        return -1;
    }

    *tamanho = 0;
    while (fscanf(arquivo, "%d %f", &sensores[*tamanho].id, &sensores[*tamanho].temperatura) == 2) {
        (*tamanho)++;
    }

    fclose(arquivo);
    return 0;
}

// (c) Média simples das temperaturas
float mediaTemperatura(Sensor sensores[], int qtd) {
    int i;
    float soma = 0;

    for (i = 0; i < qtd; i++) {
        soma += sensores[i].temperatura;
    }

    return soma / qtd;
}

// (d) Salva em binario apenas quem esta acima da media
void salvarAcimaMediaBin(const char *nomeArquivo, const Sensor *lista, int qtd, float media) {
    FILE *arquivo = fopen(nomeArquivo, "wb");
    int i;

    if (arquivo == NULL) {
        return;
    }

    for (i = 0; i < qtd; i++) {
        if (lista[i].temperatura > media) {
            fwrite(&lista[i], sizeof(Sensor), 1, arquivo);
        }
    }

    fclose(arquivo);
}

carregarSensoresTexto recebe tamanho como ponteiro para int (Aula 9) exatamente pelo mesmo motivo de argc/*tamanho em outros exercícios: a função precisa devolver, além dos dados lidos, quantos elementos foram lidos — e uma função só pode ter um valor de return, então o segundo "retorno" (a contagem) sai por referência. O parâmetro const Sensor *lista, em salvarAcimaMediaBin, usa const (Aula 12) para deixar explícito que a função só lê a lista, nunca a altera.

#include <stdio.h>
#include <math.h>

#define MAX_PONTOS 10

typedef struct {
    float x;
    float y;
} Ponto;

// Protótipos
void lerPontos(Ponto pontos[], int *tamanho);
float distancia(Ponto p1, Ponto p2);
void transladarPonto(Ponto *p, float dx, float dy);

int main() {
    Ponto pontos[MAX_PONTOS];
    int tamanho;

    lerPontos(pontos, &tamanho);

    printf("Distancia entre o 1o e o 2o ponto: %.2f\n", distancia(pontos[0], pontos[1]));

    transladarPonto(&pontos[0], 3, 2);
    printf("Primeiro ponto transladado: (%.2f, %.2f)\n", pontos[0].x, pontos[0].y);

    return 0;
}

// Implementações
void lerPontos(Ponto pontos[], int *tamanho) {
    int i;

    printf("Quantos pontos deseja informar (max %d)? ", MAX_PONTOS);
    scanf("%d", tamanho);

    for (i = 0; i < *tamanho; i++) {
        printf("Ponto %d - x: ", i);
        scanf("%f", &pontos[i].x);
        printf("Ponto %d - y: ", i);
        scanf("%f", &pontos[i].y);
    }
}

float distancia(Ponto p1, Ponto p2) {
    float dx = p1.x - p2.x;
    float dy = p1.y - p2.y;
    return sqrt(dx * dx + dy * dy);
}

void transladarPonto(Ponto *p, float dx, float dy) {
    p->x += dx;
    p->y += dy;
}

Note o parâmetro tamanho em lerPontos: dentro da função, usamos *tamanho (ou passamos o próprio tamanho, que já é um ponteiro, direto ao scanf) para ler e alterar o valor de tamanho lá na main() — o mesmo padrão do Exercício 7.

#include <stdio.h>

#define MAX_VEICULOS 100

typedef struct {
    char placa[10];
    float valorVenda;
} Veiculo;

// (b) Le "placa,valor" por linha
int abrirVeiculos(char nomeArquivo[], Veiculo veiculos[], int *tamanho) {
    FILE *arquivo = fopen(nomeArquivo, "r");

    if (arquivo == NULL) {
        return -1;
    }

    *tamanho = 0;
    while (fscanf(arquivo, "%9[^,],%f\n",
                  veiculos[*tamanho].placa, &veiculos[*tamanho].valorVenda) == 2) {
        (*tamanho)++;
    }

    fclose(arquivo);
    return 0;
}

// (c) Grava quantidade + valores em binario
void salvarValoresVeiculos(char nomeArquivo[], Veiculo veiculos[], int tamanho) {
    FILE *arquivo = fopen(nomeArquivo, "wb");
    int i;

    if (arquivo == NULL) {
        return;
    }

    fwrite(&tamanho, sizeof(int), 1, arquivo);
    for (i = 0; i < tamanho; i++) {
        fwrite(&veiculos[i].valorVenda, sizeof(float), 1, arquivo);
    }

    fclose(arquivo);
}

// (d) Recupera o n-esimo valor, pulando direto ate ele com fseek
void recuperaValorVeiculo(char nomeArquivo[], float *valorVenda, int posVeiculo) {
    FILE *arquivo = fopen(nomeArquivo, "rb");
    long deslocamento;

    if (arquivo == NULL) {
        return;
    }

    // pula o "int tamanho" inicial, e mais "posVeiculo" floats
    deslocamento = sizeof(int) + (long) posVeiculo * sizeof(float);
    fseek(arquivo, deslocamento, SEEK_SET);
    fread(valorVenda, sizeof(float), 1, arquivo);

    fclose(arquivo);
}

O deslocamento calculado em recuperaValorVeiculo é o ponto-chave (Aula 11): como o arquivo começa com um int (a quantidade) seguido de floats consecutivos, para chegar ao valor de índice posVeiculo é preciso pular sizeof(int) bytes (o cabeçalho) mais posVeiculo * sizeof(float) bytes (os valores anteriores) — sem nunca precisar ler os valores intermediários.

#include <stdio.h>

#define MAX_LIVROS 50

typedef struct {
    int codigo;
    char titulo[100];
    int exemplares;
} Livro;

// Protótipos
int totalExemplares(Livro livros[], int quantidade);
void emprestaLivro(Livro livros[], int quantidade, int codigo);

int main() {
    Livro livros[MAX_LIVROS];
    int total = 0;
    char continuar;
    int codigoEmprestimo, i;

    // (b) leitura direta na main
    do {
        printf("--- Livro %d ---\n", total + 1);
        printf("Codigo: ");
        scanf("%d", &livros[total].codigo);
        printf("Titulo: ");
        scanf(" %99[^\n]", livros[total].titulo);
        printf("Exemplares disponiveis: ");
        scanf("%d", &livros[total].exemplares);
        total++;

        printf("Cadastrar mais um livro? (s/n): ");
        scanf(" %c", &continuar);
    } while ((continuar == 's' || continuar == 'S') && total < MAX_LIVROS);

    // (c)
    printf("Total de exemplares na biblioteca: %d\n", totalExemplares(livros, total));

    // (d)
    printf("Codigo do livro a emprestar: ");
    scanf("%d", &codigoEmprestimo);
    emprestaLivro(livros, total, codigoEmprestimo);

    // (e)
    printf("\nAcervo atual:\n");
    for (i = 0; i < total; i++) {
        printf("%d - %s (%d exemplares)\n", livros[i].codigo, livros[i].titulo, livros[i].exemplares);
    }

    return 0;
}

// Implementações
int totalExemplares(Livro livros[], int quantidade) {
    int i, total = 0;

    for (i = 0; i < quantidade; i++) {
        total += livros[i].exemplares;
    }

    return total;
}

void emprestaLivro(Livro livros[], int quantidade, int codigo) {
    int i;

    for (i = 0; i < quantidade; i++) {
        if (livros[i].codigo == codigo) {
            if (livros[i].exemplares > 0) {
                livros[i].exemplares--;
                printf("Emprestimo realizado!\n");
            } else {
                printf("Nao ha exemplares disponiveis!\n");
            }
            return;
        }
    }

    printf("Codigo nao encontrado!\n");
}

Como um vetor já é, por natureza, passado como ponteiro para uma função (Aula 9), emprestaLivro consegue alterar livros[i].exemplares diretamente, mesmo sem retorno — a alteração já é visível na main() assim que a função termina, sem precisar de return nem de um parâmetro Livro * explícito adicional.

#include <stdio.h>

typedef struct {
    char nome[60];
    int idade;
    float nota;
} Aluno;

int main() {
    Aluno a;
    float notaCorte;
    int aprovados = 0;
    FILE *bin, *txt;

    printf("Nota de corte: ");
    scanf("%f", &notaCorte);

    bin = fopen("enem.bin", "rb");
    if (bin == NULL) {
        return 1;
    }

    txt = fopen("aprovados.txt", "w");
    if (txt == NULL) {
        fclose(bin);
        return 1;
    }

    while (fread(&a, sizeof(Aluno), 1, bin) == 1) {
        if (a.nota >= notaCorte) {
            fprintf(txt, "%s,%.2f\n", a.nome, a.nota);
            aprovados++;
        }
    }

    fclose(bin);
    fclose(txt);

    printf("Total de alunos aprovados: %d\n", aprovados);

    return 0;
}

Como o enunciado dispensa o uso de funções, o programa inteiro cabe na main() — mas repare que a lógica é idêntica à do Exercício 2: fread em laço para uma quantidade desconhecida de registros, filtrando e gravando em texto apenas os que atendem à condição.

#include <stdio.h>

typedef struct {
    char endereco[80];
    float area;
    char ocupacao;
} Imovel;

// Protótipos
Imovel cadastrarImovel();
void ocuparImovel(Imovel *imovel);
void exibirImovel(Imovel imovel);

int main() {
    Imovel imovel1, imovel2;

    printf("--- Imovel 1 ---\n");
    imovel1 = cadastrarImovel();

    printf("--- Imovel 2 ---\n");
    imovel2 = cadastrarImovel();

    if (imovel1.area >= imovel2.area) {
        ocuparImovel(&imovel1);
    } else {
        ocuparImovel(&imovel2);
    }

    printf("\nSituacao final:\n");
    exibirImovel(imovel1);
    exibirImovel(imovel2);

    return 0;
}

// Implementações
Imovel cadastrarImovel() {
    Imovel novo;

    printf("Endereco: ");
    scanf(" %79[^\n]", novo.endereco);
    printf("Area (m2): ");
    scanf("%f", &novo.area);
    novo.ocupacao = 'l';

    return novo;
}

void ocuparImovel(Imovel *imovel) {
    imovel->ocupacao = 'o';
}

void exibirImovel(Imovel imovel) {
    printf("%s - %.2f m2 - status: %c\n", imovel.endereco, imovel.area, imovel.ocupacao);
}

As três formas de passagem aparecem lado a lado outra vez: cadastrarImovel retorna a struct pronta (não recebe nenhum imóvel existente, então não faria sentido usar ponteiro); ocuparImovel recebe ponteiro (precisa alterar o imóvel escolhido); exibirImovel recebe por valor (só exibe, nunca altera).

#include <stdio.h>

#define MAX_RESERVAS 100

typedef struct {
    char nome_cliente[50];
    int numero_quarto;
    float valor_total;
    int pago;
} TIPO_RESERVA;

// Protótipos
int ler_clientes(TIPO_RESERVA reservas[]);
void grava_inadimplentes(TIPO_RESERVA reservas[], int quantidade);

int main() {
    TIPO_RESERVA reservas[MAX_RESERVAS];
    int quantidade, i;
    float arrecadado = 0, pendente = 0;

    quantidade = ler_clientes(reservas);

    grava_inadimplentes(reservas, quantidade);

    for (i = 0; i < quantidade; i++) {
        if (reservas[i].pago) {
            arrecadado += reservas[i].valor_total;
        } else {
            pendente += reservas[i].valor_total;
        }
    }

    printf("Total arrecadado: %.2f\n", arrecadado);
    printf("Total pendente: %.2f\n", pendente);

    return 0;
}

// Implementações
int ler_clientes(TIPO_RESERVA reservas[]) {
    FILE *arquivo = fopen("reservas.bin", "rb");
    int quantidade = 0;

    if (arquivo == NULL) {
        return 0;
    }

    while (quantidade < MAX_RESERVAS &&
           fread(&reservas[quantidade], sizeof(TIPO_RESERVA), 1, arquivo) == 1) {
        quantidade++;
    }

    fclose(arquivo);
    return quantidade;
}

void grava_inadimplentes(TIPO_RESERVA reservas[], int quantidade) {
    FILE *arquivo = fopen("inadimplentes.txt", "w");
    int i;

    if (arquivo == NULL) {
        return;
    }

    for (i = 0; i < quantidade; i++) {
        if (!reservas[i].pago) {
            fprintf(arquivo, "%s,%d,%.2f\n",
                    reservas[i].nome_cliente, reservas[i].numero_quarto, reservas[i].valor_total);
        }
    }

    fclose(arquivo);
}

ler_clientes retorna a quantidade lida (em vez de recebê-la por ponteiro, como em outros exercícios) — ambas as abordagens são válidas; aqui, como o vetor já é alterado diretamente (por já ser passado como ponteiro), sobra apenas um valor para "devolver", o que se encaixa perfeitamente em um return simples.

#include <stdio.h>

#define N 5

typedef struct {
    char titulo[50];
    char artista[30];
    int ano;
} Musica;

// Protótipos
int salvaMusicas(Musica musicas[], int n);
int buscaPorAno(int anoBusca);

int main() {
    Musica musicas[N];
    int i, anoBusca, encontradas;

    for (i = 0; i < N; i++) {
        printf("--- Musica %d ---\n", i + 1);
        printf("Titulo: ");
        scanf(" %49[^\n]", musicas[i].titulo);
        printf("Artista: ");
        scanf(" %29[^\n]", musicas[i].artista);
        printf("Ano: ");
        scanf("%d", &musicas[i].ano);
    }

    if (salvaMusicas(musicas, N) != 1) {
        printf("Erro ao salvar musicas!\n");
        return 1;
    }

    printf("Ano de interesse: ");
    scanf("%d", &anoBusca);

    encontradas = buscaPorAno(anoBusca);
    if (encontradas > 0) {
        printf("Total encontrado: %d\n", encontradas);
    } else if (encontradas == 0) {
        printf("Nenhuma musica encontrada para o ano informado.\n");
    } else {
        printf("Erro na leitura do arquivo!\n");
    }

    return 0;
}

// Implementações
int salvaMusicas(Musica musicas[], int n) {
    FILE *arquivo = fopen("cadastroMusicas.bin", "wb");

    if (arquivo == NULL) {
        return -1;
    }

    fwrite(musicas, sizeof(Musica), n, arquivo);
    fclose(arquivo);
    return 1;
}

int buscaPorAno(int anoBusca) {
    FILE *arquivo = fopen("cadastroMusicas.bin", "rb");
    Musica m;
    int encontradas = 0;

    if (arquivo == NULL) {
        return -1;
    }

    while (fread(&m, sizeof(Musica), 1, arquivo) == 1) {
        if (m.ano == anoBusca) {
            printf("%s - %s (%d)\n", m.titulo, m.artista, m.ano);
            encontradas++;
        }
    }

    fclose(arquivo);
    return encontradas;
}

O ponto central deste exercício: buscaPorAno recebe apenas o ano como parâmetro — nada do vetor original é passado para ela. A busca é feita inteiramente reabrindo "cadastroMusicas.bin" e lendo Musica por Musica com fread, exatamente como fizemos ao ler qualquer outro arquivo binário de tamanho desconhecido nesta revisão.

#include <stdio.h>

#define MAX_PRATOS 20

typedef struct {
    char nome[50];
    int notaSabor;
    int notaApresentacao;
} Prato;

int main() {
    Prato pratos[MAX_PRATOS];
    int total = 0;
    int i, notaFinal, melhorIndice, melhorNota;
    FILE *arquivo = fopen("receitas.txt", "r");

    if (arquivo == NULL) {
        return 1;
    }

    while (total < MAX_PRATOS &&
           fscanf(arquivo, " %49[^\n] %d %d",
                  pratos[total].nome, &pratos[total].notaSabor, &pratos[total].notaApresentacao) == 3) {
        total++;
    }
    fclose(arquivo);

    melhorIndice = 0;
    melhorNota = pratos[0].notaSabor + pratos[0].notaApresentacao;
    for (i = 1; i < total; i++) {
        notaFinal = pratos[i].notaSabor + pratos[i].notaApresentacao;
        if (notaFinal > melhorNota) {
            melhorNota = notaFinal;
            melhorIndice = i;
        }
    }

    printf("O prato vencedor e: %s\n", pratos[melhorIndice].nome);
    printf("Nota Final: %d\n", melhorNota);

    return 0;
}

O formato " %49[^\n] %d %d" lê, em uma única chamada de fscanf, o nome do prato (até 49 caracteres, parando na quebra de linha) seguido das duas notas na linha seguinte — os espaços entre os especificadores fazem o fscanf pular automaticamente as quebras de linha entre um campo e outro.

#include <stdio.h>

// Protótipo (exigido pelo enunciado)
void encontrarMinMaxEtrocar(int vetor[], int tamanho, int *min_encontrado, int *max_encontrado);

int main() {
    int numeros[6] = {8, 3, 9, 1, 5, 2};
    int min, max, i;

    encontrarMinMaxEtrocar(numeros, 6, &min, &max);

    printf("Minimo: %d, Maximo: %d\n", min, max);
    printf("Vetor apos a troca: ");
    for (i = 0; i < 6; i++) {
        printf("%d ", numeros[i]);
    }
    printf("\n");

    return 0;
}

// Implementação
void encontrarMinMaxEtrocar(int vetor[], int tamanho, int *min_encontrado, int *max_encontrado) {
    int i, posMin = 0, posMax = 0;
    int temp;

    for (i = 1; i < tamanho; i++) {
        if (vetor[i] < vetor[posMin]) {
            posMin = i;
        }
        if (vetor[i] > vetor[posMax]) {
            posMax = i;
        }
    }

    *min_encontrado = vetor[posMin];
    *max_encontrado = vetor[posMax];

    // troca de posicao os elementos min e max dentro do proprio vetor
    temp = vetor[posMin];
    vetor[posMin] = vetor[posMax];
    vetor[posMax] = temp;
}

Note que guardamos as posições (posMin, posMax) do menor e maior valor, e não apenas os valores — é a posição que permite tanto ler o valor (para devolvê-lo por *min_encontrado/*max_encontrado) quanto trocá-lo de lugar dentro do vetor original, já que o vetor foi passado (como sempre) como um ponteiro para seu primeiro elemento (Aula 9).