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

Plataforma: URI (BEECROWD)

Problema: 1263


Linguagem: 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 e C++:

A função strtok observa a ocorrência de um token (neste caso, um espaço em branco) para dividir a cadeia de caracteres, e assim conseguir obter a primeira letra de cada palavra daquela linha. Esta primeira letra está disponível na variável l ou em w[0]. A segunda estrutura while é responsável por esta iteração. A variável anterior obtém sempre a primeira letra da palavra anterior e, se for igual à variável l, temos uma aliteração. A variável podeContar funciona como um controlador booleano, pois ela só permitirá a contagem se a aliteração ainda não estiver sido registrada. Por exemplo, se três palavras seguidas representarem aliterações, o contador não poderia incrementar pela segunda vez, pois a aliteração já foi registrada.

Código em C++:

#include <iostream>
#include <cstring>

using namespace std;

int main() {
    
    char *w, anterior = ' ', l;
    string linha;
    
    while (getline(cin, linha)) {
        
        int n = 0;
        bool podeContar = true;
        w = strtok(&linha[0], " ");
        
        while (w != NULL) {
            
            l = w[0];
            
            if (l >= 'a' && l <= 'z')
                l -= 32;
                
            if (anterior != l)
                podeContar = true;
            else if (podeContar) {
                n++;
                podeContar = false;
            }
                
            anterior = l;
            w = strtok(NULL, " ");
        }
        
        cout << n << endl;
    }
    
    return 0;
}

Código em C:

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

int main() {
    
    char linha[5010], *w, anterior = ' ', l;
    int n, podeContar;
    
    while (scanf ("%[^\n]%*c", linha) != EOF) {
        
        n = 0;
        podeContar = 1;
        
        for (w = strtok(linha, " "); w != NULL; w = strtok(NULL, " ")) {
            
            l = w[0];
            
            if (l >= 'a' && l <= 'z')
                l -= 32;
                
            if (anterior != l)
                podeContar = 1;
            else if (podeContar) {
                n++;
                podeContar = 0;
            }
                
            anterior = l;
        }
        
        printf("%d\n", n);
    }
    
    return 0;
}

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

Plataforma: URI (BEECROWD)

Problema: 1263


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++:

Ler todas as palavras (considerar palavra toda sequência de caracteres até o espaço ou o fim da linha) e pegar o primeiro caractere dela. Ao obter o caractere, testar se ele é minúsculo e, caso positivo, passá-lo para maiúsculo, padronizando assim os caracteres para a comparação. Se o primeiro caractere de cada palavra for igual, faz o incremento da variável n, mas antes a variável podeContar controla se já houve a contagem, caso em que a aliteração já foi calculada se houver mais palavras consecutivas iniciando pela mesma letra. Ao final basta imprimir o valor de n, não esquecendo da quebra de linha.

Código em C++:

#include <iostream>
#include <sstream>

using namespace std;

int main() {
    
    string linha, w;
    char anterior = ' ', l;
    int n;
    bool podeContar;
    
    while (getline(cin, linha)) {
        
        istringstream s(linha);
        n = 0;
        podeContar = true;
        
        while (getline(s, w, ' ')) {
            
            l = w[0];
            
            if (l >= 'a' and l <= 'z')
                l -= 32;
                
            if (anterior == l) {
                if (podeContar) {
                    n++;
                    podeContar = false;
                }
            }
            else
                podeContar = true;
                
            anterior = l;
        }
        
        cout << n << endl;
    }
    
    return 0;
}

Solução em C:

A função strtok observa a ocorrência de um token (neste caso, um espaço em branco) para dividir a cadeia de caracteres, e assim conseguir obter a primeira letra de cada palavra daquela linha. Esta primeira letra está disponível na variável l ou em w[0]. A estrutura for é responsável por esta iteração. A variável anterior obtém sempre a primeira letra da palavra anterior e, se for igual à variável l, temos uma aliteração. A variável podeContar funciona como um controlador booleano, pois ela só permitirá a contagem se a aliteração ainda não estiver sido registrada. Por exemplo, se três palavras seguidas representarem aliterações, o contador não poderia incrementar pela segunda vez, pois a aliteração já foi registrada.

Código em C:

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

int main() {
    
    char linha[5010], *w, anterior = ' ', l;
    int n, podeContar, i;
    
    while (scanf ("%[^\n]%*c", linha) != EOF) {
        
        n = 0;
        podeContar = 1;
        
        w = strtok(linha, " ");
        for (i = 0; w != NULL; i++) {
            
            l = w[0];
            
            if (l >= 'a' && l <= 'z')
                l = l - 32;
                
            if (anterior == l) {
                if (podeContar) {
                    n++;
                    podeContar = 0;
                }
            }
            else
                podeContar = 1;
                
            anterior = l;
            w = strtok(NULL, " ");
        }
        
        printf("%d\n", n);
    }
    
    return 0;
}

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

Plataforma: URI (BEECROWD)

Problema: 1263


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;
}

URI - 1263 - Aliteração - Strings - C++

Plataforma: URI
Problema: 2174

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.

Linguagem: C++

Solução:
Diversas verificações são feitas nesta questão. Primeiramente, devemos verificar se o penúltimo caracter lido foi espaço. Caso contrário, deve-se ficar esperando a leitura de espaço. Quando espaço foi o penúltimo caracter lido, então é verificado se está sendo lido uma sequencia de palavras com a mesma inicial. Se já estiver em sequencia, então não deve ser computado o valor, mas se a sequencia for quebrada, deve-se anotar a nova letra inicial. Caso não esteja em sequencia, então é verificado se a nova palavra possui a mesma inicial da última, neste caso, é somado um para a saída.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <iostream> using namespace std; char upper(char letter){ if(letter >= 'a' and letter <='z'){ letter = letter - 'a' + 'A'; } return letter; } int main() { string line; while(getline(cin,line)){ int num = 0; char lastWordLetter = 'a'-1; bool space = true; bool sequence = false; for(int i=0;i<line.length();i++){ if(space){ space = false; if(!sequence){ if(upper(lastWordLetter) == upper(line[i])){ //cout << line[i] << endl; sequence = true; num++; } } // se for letra diferente... if(lastWordLetter != line[i]){ sequence = false; lastWordLetter = line[i]; } } else{ if(line[i]== ' '){ space = true; } } } cout << num << endl; } return 0; }