Exercícios de Exame

1: F, 2: F, 3: V, 4: V, 5: V, 6: F.

private é palavra reservada, pelo que a definição da 1 não compila. Em C++, -10 <= x <= 10 avalia primeiro -10 <= x (verdadeiro ou falso, convertido para 0 ou 1) e compara esse resultado com 10, pelo que a 2 é sempre verdadeira para qualquer x — não testa o intervalo. O ciclo da 3 imprime A, B, ... até à n-ésima letra. Uma string de C termina em '\0', pelo que "Hello" precisa de 6 carateres. O operador >> lê apenas até ao primeiro espaço, pelo que a 5 fica com "Ana-2003". Por fim, int &a não pode ligar-se à constante 210, pelo que a 6 é falsa.

string transformLine(string s)
{
  string result = "";
  for (size_t i = 0; i < s.length(); i++)
  {
    char c = s.at(i);
    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == ' ')
      result += c;
    else
      result += ' ';
  }
  toUpperStr(&result);
  return result;
}

Cada caráter é testado individualmente: letras e espaços copiam-se, todo o resto passa a espaço. Depois invoca-se toUpperStr sobre a string acumulada, que converte as minúsculas para maiúsculas in loco, e retorna-se essa string. A string original nunca é alterada porque se constrói uma nova.

float average(const int grades[], int numStudents)
{
  float sum = 0;
  for (int i = 0; i < numStudents; i++)
    sum += grades[i];
  return sum / numStudents;
}

Um array recebido como parâmetro decai para um apontador, pelo que o ciclo percorre as numStudents posições acumulando em sum. A divisão sum / numStudents é feita em vírgula flutuante porque sum é float, devolvendo a média como float.

void minmax(const time_of_day times[], int n, time_of_day& min, time_of_day& max)
{
  min = max = times[0];
  for (int i = 1; i < n; i++)
  {
    int t = times[i].h * 60 + times[i].m;
    int tmin = min.h * 60 + min.m;
    int tmax = max.h * 60 + max.m;
    if (t < tmin) min = times[i];
    if (t > tmax) max = times[i];
  }
}

Comparar apenas as horas não chega (por exemplo, 10:50 é maior que 11:05? não, mas 11:05 > 10:50 em horas seria falso se só se olhasse para h). Convertendo cada hora para minutos desde a meia-noite, h * 60 + m, a comparação fica correta. O primeiro elemento serve de candidato inicial a mínimo e máximo.

bool heterogram(const char s[], char r[])
{
  int count[26] = {0};
  int nrep = 0;
  for (int i = 0; s[i] != '\0'; i++)
  {
    char c = s[i];
    if (c == ' ') continue;
    if (c >= 'A' && c <= 'Z') c = c - 'A' + 'a';
    int idx = c - 'a';
    count[idx]++;
    if (count[idx] == 2) r[nrep++] = c;
  }
  r[nrep] = '\0';
  // ordenar r (insertion sort, por ser curta)
  for (int i = 1; i < nrep; i++)
  {
    char x = r[i];
    int j = i - 1;
    while (j >= 0 && r[j] > x) { r[j + 1] = r[j]; j--; }
    r[j + 1] = x;
  }
  return nrep == 0;
}

Cada letra (depois de passar a minúscula) é mapeada para um índice entre 0 e 25. A segunda vez que uma letra aparece, essa letra é acrescentada a r. Como as letras são registadas pela ordem em que aparecem, r precisa de ser ordenada no fim; como há no máximo 26 letras, um insertion sort simples chega. O heterograma é detetado quando nenhuma letra se repete.

int main()
{
  ifstream in("text.txt");
  ofstream out("words.txt");
  vector<string> total;
  string line;
  while (getline(in, line))
  {
    vector<string> words;
    decomposeLine(line, &words);
    total.insert(total.end(), words.begin(), words.end());
  }
  in.close();
  sort(total.begin(), total.end());
  for (const string& w : total)
    out << w << endl;
  out.close();
  return 0;
}

Cada linha lida é decomposta em palavras, que se juntam ao vetor acumulador total com insert. Depois ordena-se o vetor com o algoritmo sort da STL e escreve-se cada palavra numa linha do ficheiro de saída. Como não se usa um set, as repetidas mantêm-se.

Game::Game(const string &filename)
{
  ifstream f(filename);
  if (!f.is_open())
    exit(1);
  char sep;
  int numLines, numCols, lin, col;
  f >> numLines >> sep >> numCols;
  mines.resize(numLines, vector<char>(numCols, ' '));
  while (f >> lin >> sep >> col)
    mines.at(lin).at(col) = 'M';
}

A primeira linha tem o formato 10 x 10, pelo que se lêem dois inteiros separados por um caráter (sep). O vetor é redimensionado para as dimensões lidas, todo preenchido com espaços, e cada par seguinte marca uma mina com 'M'. O ciclo while termina naturalmente no fim do ficheiro. Se o ficheiro não abrir, exit(1) termina o programa com o código pedido.

void organize_grades(const string& input_fname, const string& output_fname)
{
  ifstream in(input_fname);
  ofstream out(output_fname);
  map<string, map<string, int>> grades;
  string course, name;
  int grade;
  while (in >> course >> name >> grade)
    grades[course][name] = grade;
  for (const auto& c : grades)
  {
    out << c.first << endl;
    for (const auto& s : c.second)
      out << s.first << ' ' << s.second << endl;
  }
}

Um map<string, map<string, int>> associa cada cadeira a um map de nome para nota. Como os map mantêm as chaves ordenadas, ao percorrer a estrutura externa e a interna na ordem natural escrevem-se as secções por cadeira ordenadas e, dentro de cada uma, os estudantes por nome, sem ser preciso chamar sort.

vector<unsigned int> genRandom(unsigned int n, unsigned int m)
{
  vector<unsigned int> v;
  for (unsigned int i = 0; i < n; i++)
    v.push_back(rand() % (m + 1));
  return v;
}

rand() % (m + 1) produz valores uniformes entre 0 e m, inclusive. O ciclo corre n vezes, acrescentando cada valor ao vetor, que é devolvido por valor (a STL trata da cópia).

unsigned int vectorReduce(const vector<unsigned int> &v1, vector<unsigned int> &v2)
{
  unsigned int count = 0;
  for (size_t i = 0; i < v2.size(); )
  {
    bool found = false;
    for (size_t k = 0; k < v1.size(); k++)
      if (v2[i] == v1[k]) { found = true; break; }
    if (found)
    {
      v2.erase(v2.begin() + i);
      count++;
    }
    else
      i++;
  }
  return count;
}

Percorre-se v2 elemento a elemento e, para cada um, verifica-se se pertence a v1. Se pertencer, remove-se com erase e incrementa-se o contador; como a remoção desloca os elementos seguintes para a esquerda, o índice só avança quando o elemento atual não é removido. No exemplo, 2, 2 e 3 são removidos, sobrando {4, 5} e com 3 remoções registadas. Alternativamente, pode usar-se o idiom erase-remove com remove_if e find.

auto it = find(v.begin(), v.end(), "31");
if (it != v.end())
  cout << "Element found";
else
  cout << "Element not found";

Sim, é possível: basta passar v.begin() e v.end() como iteradores de entrada e "31" como valor a procurar (a comparação usa operator== de string). A função retorna um iterador para a primeira ocorrência ou para v.end() se não existir, pelo que a comparação com v.end() decide se o valor foi encontrado.

Um std::set é um contentor associativo ordenado que, por omissão, usa std::less<Position>, o que exige o operador < para Position. Como a struct não o sobrecarrega, a instanciação do set falha na compilação. A solução é definir bool operator<(const Position&, const Position&) (por exemplo, comparando primeiro lin e depois col) ou declarar o set com um tipo comparador próprio, como set<Position, ComparaPosition>.

Os contentores ordenados da STL (set, map, ...) precisam de uma relação de ordem estrita entre os elementos. Sem operator< para Position, o modelo interno do set não compila. Basta acrescentar a sobrecarga do operador ou fornecer um functor comparador como segundo parâmetro do template.

bool Student::setGrade(int courseId, int grade)
{
  bool isEnrolled = false;
  for (auto c : courses)
    if (c->getId() == courseId)
    {
      isEnrolled = true;
      break;
    }
  if (!isEnrolled) return false;
  if (grades.find(courseId) != grades.end()) return false;
  grades[courseId] = grade;
  return true;
}

Percorre-se o vetor de apontadores courses para confirmar a matrícula; se nenhum curso tiver o courseId, retorna-se false. Depois, grades.find(courseId) != grades.end() deteta uma nota já existente. Só se ambas as verificações passarem se insere a nota no map (com grades[courseId] = grade ou insert) e se retorna true.

int Student::getAverageGrade() const
{
  float sum = 0;
  for (auto x : grades)
    sum += x.second;
  return (int)(sum / grades.size() + 0.5);
}

Num map<int, int>, cada elemento é um par (chave, valor); a nota é o second. Somam-se todos os valores e divide-se pelo número de elementos. Somar 0.5 antes do truncamento para int arredonda para o inteiro mais próximo (para valores positivos).

bool Board::putShip(const Ship &s)
{
  if (!canPutShip(s.pos(), s.dir(), s.size()))
    return false;
  if (s.dir() == 'H')
    for (size_t i = 0; i < s.size(); i++)
      board.at(s.pos().lin).at(s.pos().col + i) = s.id();
  else
    for (size_t i = 0; i < s.size(); i++)
      board.at(s.pos().lin + i).at(s.pos().col) = s.id();
  ships.push_back(s);
  return true;
}

Primeiro delega-se a validação em canPutShip. Se passar, preenchem-se as size células a partir do canto superior esquerdo (pos()), na horizontal (col + i) ou na vertical (lin + i), com o identificador do navio, e regista-se o navio em ships. A devolução é true apenas se o navio ficou colocado.

(a) Com virtual: 23, 2, 23. (b) Sem virtual na base: 23, 2, 2. (c) Com private em vez de protected, erro de compilação.

d.show() chama o método de Derived (23). A atribuição Base b = d; copia apenas a parte base do objeto (slicing), pelo que b.show() chama Base::show e imprime 2. A chamada pb->show() é dinâmica por causa de virtual, apesar de o apontador ser de Base, e imprime 23. Sem virtual, essa chamada resolve estaticamente para Base::show, imprimindo 2. Se _a fosse private, a classe Derived não poderia aceder-lhe no seu próprio show(), pelo que o código nem compilava.

class Car : public Vehicle {
public:
  Car(std::string make, std::string model, int year, int numberOfDoors)
      : Vehicle(make, model, year), numberOfDoors_(numberOfDoors) {}
  int numberOfDoors() const { return numberOfDoors_; }
  void displayInfo() const override {
    Vehicle::displayInfo();
    std::cout << numberOfDoors_ << " doors";
  }
private:
  int numberOfDoors_;
};

class Bike : public Vehicle {
public:
  Bike(std::string make, std::string model, int year, bool isElectric)
      : Vehicle(make, model, year), isElectric_(isElectric) {}
  bool isElectric() const { return isElectric_; }
  void displayInfo() const override {
    Vehicle::displayInfo();
    std::cout << (isElectric_ ? "electric" : "muscular");
  }
private:
  bool isElectric_;
};

Cada subclasse chama o construtor da base com Vehicle(make, model, year) na lista de inicialização e guarda o atributo próprio. O método displayInfo() sobreposto chama primeiro Vehicle::displayInfo() para reutilizar a saída base e depois acrescenta a informação específica, com override para o compilador confirmar a sobreposição do método virtual.