Pesquisar este blog

Livros Recomendados

sexta-feira, 26 de março de 2021

URI (BEECROWD) - 1263 - Aliteração - Strings - C e C++

Plataforma: URI (BEECROWD)

Problema1263


Linguagens: C e C++

Enunciado:
Uma aliteração ocorre quando duas ou mais palavras consecutivas de um texto possuem a mesma letra inicial (ignorando maiúsculas e minúsculas). Sua tarefa é desenvolver um programa que identifique, a partir de uma sequência de palavras, o número de aliterações que essa sequência possui.

Solução em C++:

Aqui utilizou-se vector de caracteres, chamado palavras, para armazenar o primeiro caractere de cada palavra digitada. Assim, verificou-se os caracteres de posições contíguas do vector e, se eram iguais e se a aliteração já não foi contabilizada (a variável lock cuida disso), tem-se uma nova aliteração e incrementa-se a variável n, que é a resposta.

#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

int main() {
    
    string linha;
    vector<char> palavras;
    int n;
    bool lock;
    while (getline(cin, linha)) {
        istringstream s(linha);
        string w;
        while (getline(s, w, ' ')) {
            if (w[0] >= 'a' and w[0] <= 'z')
                w[0] = w[0] - 32;
            palavras.push_back(w[0]);
        }
        lock = false;
        int tam = palavras.size();
        n = 0;
        for (int i = 1; i < tam; i++) {
            if (palavras.at(i) == palavras.at(i-1)) {
                if (!lock) {
                    n++;
                    lock = true;
                }
            }
            else
                lock = false;
        }
        cout << n << endl;
        palavras.clear();
    }

    return 0;
}

Solução em C:

A proposta é ler as palavras e passar a inicial de cada palavra para maiúsculo. Esta inicial é armazenada no array palavras. Sempre que o array palavras no índice atual tiver o mesmo valor que o array no índice anterior, tem-se uma aliteração, no entanto, a variável lock controla se pode incrementar a variável n (que contém a resposta), pois as duas palavras anteriores já podem ser uma aliteração com a mesma letra. Portanto, só incrementa quando ainda não foi detectada aquela aliteração.

Na solução apresentada, para saber a quantidade de palavras, verificou-se o tamanho do array palavras, que contém a letra inicial de cada palavra. Portanto, contando cada letra (ou o tamanho de palavras) saberemos quantas palavras temos. Poderia ser usada a função strlen, mas nesta solução preferiu-se implementar uma função semelhante, chamada getTam.

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

size_t getTam(const char *s) {
    size_t t = 0;
    while (++t)
        if (!s[t])
            return t;
            
}
int main() {
    char linha[5010], palavras[101], *w;
    int n, lock, i, tam;
    while (scanf ("%[^\n]%*c", linha) != EOF) {
        w = strtok(linha, " ");
        for (i = 0; w != NULL; i++) {
            if (w[0] >= 'a' && w[0] <= 'z')
                w[0] = w[0] - 32;
            palavras[i] = w[0];
            w = strtok(NULL, " ");
        }
        lock = 0;
        tam = getTam(palavras);
        n = 0;
        for (i = 1; i < tam; i++) {
            if (palavras[i] == palavras[i-1]) {
                if (!lock) {
                    n++;
                    lock = 1;
                }
            }
            else
                lock = 0;
        }
        printf("%d\n", n);
        memset(palavras, 0, 101 * sizeof(char));
    }
    return 0;
}

Nenhum comentário:

Postar um comentário

Postagem em destaque

URI (BEECROWD) - 2158 - Helping Uncle Cláudio (Ajudando o Tio Cláudio) - Matemática - C, C++ e Haskell

Buenas! Estou aqui mais uma vez para resolver um problema de Matemática! Agora tenho resolvido alguns dessa categoria, pra que vocês possam ...

Postagens mais visitadas