Removendo duplicatas de uma lista encadeada ordenada

Em uma lista ordenada, valores iguais ficam adjacentes. Basta percorrer a lista com um ponteiro e comparar o nó atual com o próximo. Se forem iguais, o próximo nó é desconectado; caso contrário, avançamos.

struct ListNode {
    int val;
    ListNode *next;
};

ListNode* removeDuplicates(ListNode* head) {
    if (!head) return head;

    ListNode* atual = head;
    while (atual->next) {
        if (atual->val == atual->next->val) {
            ListNode* repetido = atual->next;
            atual->next = repetido->next;
            delete repetido;
        } else {
            atual = atual->next;
        }
    }
    return head;
}

Importante: guardamos o endereço do primeiro nó em uma variável separada para poder retorná-lo ao final. Sem isso, perderíamos a referência ao início da lista.

Busca do menor elemento e de seu índice

Uma aobrdagem direta é inicializar o menor valor com o primeiro elemento e, em seguida, varrer o restante do vetor atualizando o valor e a posição sempre que um elemento estritamente menor for encontrado.

#include <iostream>
#include <vector>

int main() {
    int n;
    std::cin >> n;
    std::vector<int> valores(n);

    for (int i = 0; i < n; ++i) {
        std::cin >> valores[i];
    }

    int menor = valores[0];
    int posicao = 0;

    for (int i = 1; i < n; ++i) {
        if (valores[i] < menor) {
            menor = valores[i];
            posicao = i;
        }
    }

    std::cout << "Menor: " << menor << " / Indice: " << posicao;
    return 0;
}

Soma ou média de uma coluna da matriz

Dada uma matriz de dimensões fixas, podemos somar os elementos de uma coluna escolhida e, opcionalmente, calcular a média.

#include <iostream>
#include <vector>

int main() {
    const int TAM = 4;
    std::vector<std::vector<double>> matriz(TAM, std::vector<double>(TAM));

    int coluna;
    char operacao;
    std::cin >> coluna >> operacao;

    for (int i = 0; i < TAM; ++i)
        for (int j = 0; j < TAM; ++j)
            std::cin >> matriz[i][j];

    double soma = 0.0;
    for (int i = 0; i < TAM; ++i)
        soma += matriz[i][coluna];

    if (operacao == 'M')
        soma /= TAM;

    std::cout << soma;
    return 0;
}

Soma ou média da parte inferior direita de uma matriz 12x12

Para uma matriz 12x12, a região triangular abaixo e à direita da diagonal principle pode ser percorrida fixando-se o limite inferior de j em função de i. A quantidade de elementos dessa região é dada pela soma dos 11 primeiros inteiros.

#include <iostream>
#include <iomanip>

int main() {
    const int N = 12;
    double m[N][N];

    char op;
    std::cin >> op;

    for (int i = 0; i < N; ++i)
        for (int j = 0; j < N; ++j)
            std::cin >> m[i][j];

    double soma = 0.0;
    for (int i = 1; i < N; ++i) {
        for (int j = N - 1; j >= N - i; --j) {
            soma += m[i][j];
        }
    }

    double resultado = soma;
    if (op == 'M') {
        int quantidade = (1 + (N - 1)) * (N - 1) / 2;
        resultado /= quantidade;
    }

    std::cout << std::fixed << std::setprecision(1) << resultado;
    return 0;
}

Leitura e manipulação de strings em C++

Valores úteis da tabela ASCII:

• '0' → 48
• 'A' → 65
• 'a' → 97

Strings estilo C

char buffer[100];
fgets(buffer, 100, stdin);   // inclui o '\n' se houver
puts(buffer);

Para ignorar o caractere de nova linha em algumas situações, pode-se usar:

cin.getline(buffer, 100);

Funções da biblioteca <cstring>

• strlen(s): retorna o comprimento da string.
• strcmp(a, b): compara duas strings; retorna < 0, 0 ou > 0.
• strcpy(a, b): copia b para a.

Classe std::string

A std::string faz parte da STL e está disponível em <string>. Exemplos de inicialização:

std::string s1;                 // vazia
std::string s2 = s1;            // cópia
std::string s3 = "hello";       // literal
std::string s4(10, 'c');        // "cccccccccc"

Operações comuns:

std::string s;
std::getline(std::cin, s);      // lê uma linha inteira

if (!s.empty()) { /* ... */ }

for (char c : s) {
    std::cout << c << '\n';
}

Exemplo: cifra de César simples

O código abaixo desloca cada letra em uma posição no alfabeto, fazendo o retorno de Z para A e de z para a.

#include <iostream>
#include <cstring>

int main() {
    char texto[101];
    std::fgets(texto, 101, stdin);

    int n = std::strlen(texto);
    for (int i = 0; i < n; ++i) {
        char c = texto[i];
        if (c >= 'A' && c < 'Z') {
            texto[i] = c + 1;
        } else if (c == 'Z') {
            texto[i] = 'A';
        } else if (c >= 'a' && c < 'z') {
            texto[i] = c + 1;
        } else if (c == 'z') {
            texto[i] = 'a';
        }
    }

    std::cout << texto;
    return 0;
}

Média mínima entre pares de menor e maior valor

O problema consiste em formar pares contendo o menor e o maior valores resatntes e encontrar a menor média entre esses pares. A solução mais simples e eficiente é ordenar o vetor e emparelhar o início com o fim.

#include <algorithm>
#include <vector>
#include <limits>

class Solution {
public:
    double minimumAverage(std::vector<int>& nums) {
        std::sort(nums.begin(), nums.end());

        int n = nums.size();
        double melhor = std::numeric_limits<double>::max();

        for (int i = 0; i < n / 2; ++i) {
            double media = (nums[i] + nums[n - 1 - i]) / 2.0;
            melhor = std::min(melhor, media);
        }

        return melhor;
    }
};

Após a ordenação, a combinação nums[i] com nums[n - 1 - i] garante que sempre estaremos somando o menor disponível com o maior disponível em cada posição.