URI (BEECROWD) - 1272 - Hidden Message (Mensagem Oculta) - Strings - Haskell

Olá!

Aqui vai mais um novo post!

Dessa vez vou resolver um problema da categoria Strings do Beecrowd. Esse problema é o "Mensagem Oculta", ou Hidden Message.

Veja abaixo como eu resolvi este problema!

Ah, só mais um pedido: ajude o blog! PIX: 6d8bc7a8-5d74-493a-ab7a-3515baf35956

Plataforma: URI (BEECROWD)

Problema: 1272

Enunciado:
Textos podem conter mensagens ocultas. Neste problema a mensagem oculta em um texto é composto pelas primeiras letras de cada palavra do texto, na ordem em que aparecem. É dado um texto composto apenas por letras minúsculas ou espaços. Pode haver mais de um espaço entre as palavras. O texto pode iniciar ou terminar em espaços, ou mesmo conter somente espaços.

Linguagem: Haskell

Solução: 

A estratégia utilizada foi ler cada linha e separar cada palavra (expressão até encontrar um espaço em branco) com a função words. Para cada palavra, executa a função que obtém o primeiro caractere dela (head). Isso é feito para cada palavra gerada por meio de uma função de alta ordem chamada map. O código fica da seguinte forma:

main :: IO ()
main = do
   n <- readLn :: IO Int
   reading n

reading :: Int -> IO ()
reading n = do
   if n == 0
      then return ()
      else do
         line <- getLine
         putStrLn (map head (words line))
         reading (n-1)

imprimo sempre o caractere imediatamente após um espaço em branco.

#include <iostream>
#include <cctype>

using namespace std;

int main() {
    
    int n;
    string linha;
    cin >> n;
    cin.ignore();
    while (n--) {
        getline(cin, linha);
        
        if (isalpha(linha[0]))
            cout << linha[0];
        for (int i = 1; i < linha.size(); i++) {
            if (linha[i] != ' ') {
                while (linha[i] == ' ')
                    i++;
            }
            if (isalpha(linha[i]) && linha[i-1] == ' ')
                cout << linha[i];
        }
        cout << endl;
    }

    return 0;
}

Solução alternativa:

Há várias soluções possíveis. Aqui, embora a ideia seja muito parecida, utilizei composição de funções e a mônada replicateM.

As linhas foram lidas com replicateM, que replica o comando getLine n vezes.

O comando de saída putStrLn intercala os resultados com \n, ou seja, exibe um resultado por linha. O resultado é o mapeamento da função (map head . words) aplicado em lines, ou seja, obtém-se o primeiro caractere de cada palavra de cada linha.

import Control.Monad (replicateM)
import Data.List (intercalate)

main :: IO ()
main = do
  n <- readLn :: IO Int
  lines <- replicateM n getLine
  putStrLn (intercalate "\n" (map (map head . words) lines))