Lista 01 · Primeiros passos em C++

Exercícios da Semana 1 — Primeiros passos em C++. O foco aqui é std::string (no lugar de char[]), auto, const e a diferença entre trabalhar com std::cin/std::cout e o printf/scanf que você já conhece de C.

Como resolver

Copie o bloco de código de cada exercício, cole no seu compilador online, preencha a parte marcada como ESCREVA SUA SOLUCAO AQUI e rode. A saída mostra quais testes passaram.

ex01

Escreva a função saudacao, que recebe um nome (std::string) e devolve a saudação no formato "Ola, <nome>!".

Em C, você faria isso com sprintf e um buffer char[] de tamanho fixo, torcendo para o nome não estourar o buffer. Em C++, std::string cresce sozinha e + concatena.

saudacao("Maria")  // -> "Ola, Maria!"
saudacao("")       // -> "Ola, !"

// ex01 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>
#include <string>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX01_H
#define EX01_H

// Retorna uma saudacao no formato "Ola, <nome>!".
// Ex: saudacao("Maria") -> "Ola, Maria!"
std::string saudacao(const std::string& nome);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
std::string saudacao(const std::string& nome) {
    // TODO: monte e retorne a string "Ola, " + nome + "!"
    return "";
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(saudacao("Maria") == std::string("Ola, Maria!"));
    assert(saudacao("Joao") == std::string("Ola, Joao!"));
    assert(saudacao("") == std::string("Ola, !"));
    assert(saudacao("Ana Paula") == std::string("Ola, Ana Paula!"));
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex02

Escreva media, que recebe três notas (double) e devolve a média aritmética.

Use auto para a variável que guarda o resultado antes de retornar — deixe o compilador inferir o tipo:

auto resultado = (a + b + c) / 3.0;

// ex02 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>
#include <cmath>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX02_H
#define EX02_H

// Retorna a media aritmetica de tres notas.
double media(double a, double b, double c);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
double media(double a, double b, double c) {
    // TODO: use "auto" para a variavel de resultado e retorne a media.
    return 0.0;
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(std::abs((media(10.0, 10.0, 10.0)) - (10.0)) <= (0.0001));
    assert(std::abs((media(0.0, 0.0, 0.0)) - (0.0)) <= (0.0001));
    assert(std::abs((media(10.0, 7.0, 4.0)) - (7.0)) <= (0.0001));
    assert(std::abs((media(5.0, 6.0, 7.0)) - (6.0)) <= (0.0001));
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex03

Escreva inverte, que recebe um texto (std::string) e devolve o texto invertido, sem usar nenhuma função pronta de inversão (nada de std::reverse ainda — isso vem na Unidade 2). Percorra o texto caractere por caractere.

inverte("abc")    // -> "cba"
inverte("ana")    // -> "ana"
inverte("")       // -> ""

// ex03 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>
#include <string>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX03_H
#define EX03_H

// Retorna o texto invertido caractere por caractere.
std::string inverte(const std::string& texto);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
std::string inverte(const std::string& texto) {
    // TODO: monte uma nova string percorrendo "texto" de tras para frente.
    return "";
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(inverte("abc") == std::string("cba"));
    assert(inverte("ana") == std::string("ana"));
    assert(inverte("") == std::string(""));
    assert(inverte("a") == std::string("a"));
    assert(inverte("cpp") == std::string("ppc"));
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex04

Escreva conta_vogais, que recebe um texto e devolve quantas vogais (a, e, i, o, u, maiúsculas ou minúsculas) ele tem.

conta_vogais("banana")   // -> 3
conta_vogais("Programacao") // -> 5
conta_vogais("xyz")      // -> 0

// ex04 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>
#include <string>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX04_H
#define EX04_H

// Conta quantas vogais (a,e,i,o,u, maiusculas ou minusculas) o texto tem.
int conta_vogais(const std::string& texto);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
int conta_vogais(const std::string& texto) {
    // TODO: percorra "texto" e conte as vogais (ignore maiusculas/minusculas).
    return 0;
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(conta_vogais("banana") == 3);
    assert(conta_vogais("Programacao") == 5);
    assert(conta_vogais("xyz") == 0);
    assert(conta_vogais("") == 0);
    assert(conta_vogais("AEIOU") == 5);
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex05

Escreva maior_de_tres, que recebe três inteiros e devolve o maior deles.

maior_de_tres(3, 9, 5)     // -> 9
maior_de_tres(-1, -5, -2)  // -> -1
maior_de_tres(4, 4, 4)     // -> 4

// ex05 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX05_H
#define EX05_H

// Retorna o maior entre tres inteiros.
int maior_de_tres(int a, int b, int c);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
int maior_de_tres(int a, int b, int c) {
    // TODO: retorne o maior dos tres valores.
    return 0;
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(maior_de_tres(3, 9, 5) == 9);
    assert(maior_de_tres(-1, -5, -2) == -1);
    assert(maior_de_tres(4, 4, 4) == 4);
    assert(maior_de_tres(0, 0, 1) == 1);
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex06

Escreva eh_palindromo, que recebe um texto e devolve true se ele é igual ao seu inverso, e false caso contrário. Não considere espaços ou acentos — os casos de teste usam apenas palavras simples.

eh_palindromo("arara")   // -> true
eh_palindromo("ovo")     // -> true
eh_palindromo("banana")  // -> false

Dica: você já escreveu uma função que inverte string no exercício 3 — pense em como reaproveitar essa lógica aqui.

// ex06 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>
#include <string>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX06_H
#define EX06_H

// Retorna true se o texto for igual ao seu inverso.
bool eh_palindromo(const std::string& texto);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
bool eh_palindromo(const std::string& texto) {
    // TODO: compare o texto com o seu inverso (letra por letra ou construindo
    // uma string invertida, como no exercicio 3).
    return false;
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(eh_palindromo("arara"));
    assert(eh_palindromo("ovo"));
    assert(!(eh_palindromo("banana")));
    assert(eh_palindromo(""));
    assert(eh_palindromo("a"));
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex07

Escreva soma_quadrados, que recebe dois inteiros e devolve a soma dos quadrados deles.

soma_quadrados(3, 4)    // -> 25   (9 + 16)
soma_quadrados(0, 5)    // -> 25
soma_quadrados(-2, 2)   // -> 8

// ex07 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX07_H
#define EX07_H

// Retorna a soma dos quadrados de a e b.
int soma_quadrados(int a, int b);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
int soma_quadrados(int a, int b) {
    // TODO: retorne a*a + b*b.
    return 0;
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(soma_quadrados(3, 4) == 25);
    assert(soma_quadrados(0, 5) == 25);
    assert(soma_quadrados(-2, 2) == 8);
    assert(soma_quadrados(0, 0) == 0);
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex08

Escreva media_geometrica, que recebe dois double e devolve a média geométrica deles: multiplique os dois números e tire a raiz quadrada do resultado (std::sqrt, de <cmath>).

media_geometrica(4.0, 9.0)    // -> 6.0
media_geometrica(2.0, 8.0)    // -> 4.0
media_geometrica(5.0, 5.0)    // -> 5.0

// ex08 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>
#include <cmath>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX08_H
#define EX08_H

// Retorna a media geometrica de a e b: a raiz quadrada de (a * b).
double media_geometrica(double a, double b);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
double media_geometrica(double a, double b) {
    // TODO: multiplique a por b e devolva a raiz quadrada (std::sqrt) do produto.
    return 0.0;
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(std::abs((media_geometrica(4.0, 9.0)) - (6.0)) <= (0.0001));
    assert(std::abs((media_geometrica(2.0, 8.0)) - (4.0)) <= (0.0001));
    assert(std::abs((media_geometrica(5.0, 5.0)) - (5.0)) <= (0.0001));
    assert(std::abs((media_geometrica(1.0, 0.0)) - (0.0)) <= (0.0001));
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex09

Escreva remove_caractere, que recebe um texto e um caractere, e devolve um novo texto igual ao original mas sem nenhuma ocorrência daquele caractere. A comparação distingue maiúscula de minúscula ('a' é diferente de 'A').

remove_caractere("banana", 'a')       // -> "bnn"
remove_caractere("Casa Amarela", 'a') // -> "Cs Amrel"
remove_caractere("abc", 'z')          // -> "abc"

// ex09 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>
#include <string>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX09_H
#define EX09_H

// Retorna texto sem nenhuma ocorrencia do caractere alvo
// (a comparacao distingue maiuscula de minuscula).
std::string remove_caractere(const std::string& texto, char alvo);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
std::string remove_caractere(const std::string& texto, char alvo) {
    // TODO: percorra texto e monte uma nova string so com os caracteres
    // diferentes de alvo (use += para ir concatenando).
    return "";
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(remove_caractere("banana", 'a') == std::string("bnn"));
    assert(remove_caractere("Casa Amarela", 'a') == std::string("Cs Amrel"));
    assert(remove_caractere("abc", 'z') == std::string("abc"));
    assert(remove_caractere("", 'a') == std::string(""));
    assert(remove_caractere("aaa", 'a') == std::string(""));
    std::cout << "Todos os testes passaram!\n";
    return 0;
}

ex10

Escreva soma_digitos, que recebe um inteiro não negativo e devolve a soma dos seus algarismos.

Este é um exercício de lógica pura, sem nada de C++ novo: a ideia é ir tirando o último algarismo com % 10 e descartando-o com / 10, até não sobrar nada.

soma_digitos(253)    // -> 10   (2 + 5 + 3)
soma_digitos(1000)   // -> 1
soma_digitos(0)      // -> 0

// ex10 — versao de arquivo unico (gerada automaticamente,
// nao edite este arquivo direto: edite os fontes em exercicios/ e rode
// tools/gerar_single.py --todos de novo).
//
// Cole este arquivo inteiro no seu compilador online e rode.

#include <cassert>
#include <iostream>

// ============================================================
// Declaracoes do exercicio
// ============================================================
#ifndef EX10_H
#define EX10_H

// Retorna a soma dos algarismos de n (n >= 0).
int soma_digitos(int n);

#endif

// ============================================================
// ESCREVA SUA SOLUCAO AQUI
// ============================================================
int soma_digitos(int n) {
    // TODO: enquanto n for maior que zero, some o ultimo algarismo
    // (n % 10) e descarte-o (n = n / 10).
    return 0;
}

// ============================================================
// NAO ALTERE — testes
// ============================================================
int main() {
    assert(soma_digitos(253) == 10);
    assert(soma_digitos(7) == 7);
    assert(soma_digitos(1000) == 1);
    assert(soma_digitos(0) == 0);
    assert(soma_digitos(999) == 27);
    std::cout << "Todos os testes passaram!\n";
    return 0;
}