URI (BEECROWD) - 1803 - Matring - Strings - C, C++ e Haskell

Olá! Novo post de Strings! E novamente resolvido em três linguagens, que são C, C++ e Haskell.  Porém, dessa vez para C++ e Haskell eu apresentei duas soluções.

O problema resolvido é o "Matring".

E fica o pedido para que ajudem o blog, a chave PIX é 6d8bc7a8-5d74-493a-ab7a-3515baf35956. 

Valeu e até a próxima!

Plataforma: URI (BEECROWD)

Problema: 1803

Enunciado:

Matring é uma mistura de Matriz e String. Ela foi desenvolvida pela UNILA (União dos Nerds para Integração da Lógica e da Aventura) para manter mensagens seguras de escutas.

A primeira e última coluna de uma matring guarda a chave para traduzi-la na mensagem original. As colunas restantes de uma matring representam uma string codificada em ASCII, uma coluna por caractere.

Para uma mensagem com N caracteres, a matring correspondente é uma matriz 4x(N+2) de dígitos. Cada coluna é lida como um número de 4 dígitos; uma sequência de dígitos de cima para baixo é o mesmo que uma sequência de dígitos da esquerda para a direita na horizontal.

Seja o primeiro número F, o último número L e os restantes uma sequência de números Mi, onde 1 ≤ i ≤ N. A primeira coluna de uma matring é indexada por zero.

Para decodificar uma matring para uma string, calculamos: Ci = (F * Mi + L) mod 257, onde Ci é o caractere em ASCII na posição i da mensagem original.

Sua tarefa é desenvolver um algoritmo para decodificar matrings.

Linguagem: C, C++ e Haskell

Solução: 

Aqui eu fiz de algumas formas diferentes, confira abaixo!

Código em C:

#include <stdio.h>
#define LINHAS 4
#define MAXTAM 85

size_t obtemTamanho(const char *s) {
    size_t t = 0;
    while (++t)
        if (!s[t])
            return t;
}

int main() {
    int i;
    int j;
    int f;
    int l;
    int ultimo;
    int tamanho;
    int multiplicador;
    int caractereDecodificado;
    int valores[MAXTAM];
    char m[LINHAS][MAXTAM];

    for (i = 0; i < LINHAS; i++)
        scanf("%s", m[i]);

    tamanho = obtemTamanho(m[0]);
    for (i = 0; i < tamanho; i++) {
        valores[i] = 0;
        for (j = 0, multiplicador = 1000; j < LINHAS; j++, multiplicador /= 10)
            valores[i] += (m[j][i] - 48) * multiplicador;
    }

    ultimo = tamanho - 1;
    f = valores[0];
    l = valores[ultimo];
    for (i = 1; i < ultimo; i++) {
        caractereDecodificado = (f * valores[i] + l) % 257;
        printf("%c", caractereDecodificado);
    }

    printf("\n");

    return 0;
}

Código em C++:

Solução 1:

#include <iostream>
#include <string>

int main() {
    const int LINHAS = 4;
    const int MAXTAM = 85;
    int i;
    int j;
    int f;
    int l;
    int ultimo;
    int tamanho;
    int multiplicador;
    int valores[MAXTAM];
    char caractereDecodificado;
    std::string m[LINHAS];

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

    tamanho = m[0].size();

    for (i = 0; i < tamanho; i++) {
        valores[i] = 0;
        for (j = 0, multiplicador = 1000; j < LINHAS; j++, multiplicador /= 10)
            valores[i] += (m[j][i] - 48) * multiplicador;
    }

    ultimo = tamanho - 1;
    f = valores[0];
    l = valores[ultimo];
    for (i = 1; i < ultimo; i++) {
        caractereDecodificado = (f * valores[i] + l) % 257;
        std::cout << caractereDecodificado;
    }

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

Solução 2:

#include <iostream>
#include <string>

int main() {
    const int LINHAS = 4;
    const int MAXTAM = 85;
    int i;
    int j;
    int f;
    int l;
    int ultimo;
    int tamanho;
    int multiplicador;
    int valores[MAXTAM] = {0};
    char caractereDecodificado;
    std::string m[LINHAS];

    for (i = 0, multiplicador = 1000; i < LINHAS; i++, multiplicador /= 10) {
        std::cin >> m[i];
        if (!i) 
            tamanho = m[0].size();
        for (j = 0; j < tamanho; j++)
            valores[j] += (m[i][j] - 48) * multiplicador;
    }

    ultimo = tamanho - 1;
    f = valores[0];
    l = valores[ultimo];
    for (i = 1; i < ultimo; i++) {
        caractereDecodificado = (f * valores[i] + l) % 257;
        std::cout << caractereDecodificado;
    }

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

Código em Haskell:

Solução 1:

import Control.Monad (replicateM)
import Data.Char

main :: IO ()
main = do
    let linhas = 4
    m <- replicateM linhas getLine
    let tamanho = length (head m)
        valores = map (\i -> sum [digitToInt (m !! j !! i) * 10^(linhas - j - 1) | j <- [0..linhas-1]]) [0..tamanho-1]
        f = head valores
        l = last valores
        resposta = [chr (mod (f * v + l) 257) | v <- tail (init valores)]
    putStrLn resposta

Solução 2:

import Control.Monad (replicateM)
import Data.Char (chr, digitToInt)
import Data.List (transpose)

somaElementos :: [[Int]] -> [Int]
somaElementos [] = []
somaElementos ([]:_) = []
somaElementos lists = sum (map head lists) : somaElementos (map tail lists)

calcula :: [[Char]] -> Int -> [[Int]]
calcula [] _ = []
calcula _ 0 = []
calcula (x:xs) n = (map (*n) (map digitToInt x)):(calcula xs (div n 10))

obtemResposta :: [Int] -> Int -> Int -> [Char]
obtemResposta [] _ _ = []
obtemResposta (x:xs) f l = (chr (mod (f * x + l) 257)) : obtemResposta xs f l

main :: IO ()
main = do
   let linhas = 4
   m <- replicateM linhas getLine
   let tamanho = length (head m)
       inicial = 1000
       parcial = calcula m inicial
       listaTransposta = transpose parcial
       valores = map sum listaTransposta
       f = head valores
       l = last valores
       respostaTotal = obtemResposta valores f l
       resposta = init (tail respostaTotal)
   putStrLn resposta