URI (BEECROWD) - 3049 - Nota Cortada - Matemática - C, C++ e Haskell

Novamente, post de exercício de Matemática! Esse é o exercício Nota Cortada. Achei ele bem interessante, bom pra quem está iniciando em programação. 

Plataforma: URI (BEECROWD)

Problema: 3049

Linguagens: C, C++ e Haskell

Enunciado:

Se pegarmos uma nota de 100 reais e a cortarmos, usando uma tesoura, em dois pedaços, quanto vale cada um dos pedaços? A regra é simples: se um dos pedaços possuir estritamente mais da metade da área da nota original, então ele vale 100 reais; e o outro pedaço não vale nada. Veja que se cada pedaço possuir exatamente metade da área original, então nenhum dos dois tem valor.

Felix e Marzia decidiram fazer um corte, em linha reta, que comece no lado inferior da nota, a base, e termine no lado superior, o topo. A nota é um retângulo de comprimento 160 centímetros e altura 70 centímetros, como mostrado na parte esquerda da figura abaixo. Felix sempre vai ficar com o pedaço mais à esquerda da nota e Marzia com o pedaço mais à direita. A parte direita da figura ilustra dois possíveis cortes. No de cima, Marzia ficaria claramente com o maior pedaço, que vale 100 reais; e no de baixo, dá para ver que Felix é quem ficaria com o maior pedaço.

O corte reto vai começar na base a uma distância de B centímetros a partir do lado esquerdo da nota; e terminar no topo a uma distância de T centímetros também a partir do lado esquerdo da nota. Veja a indicação na parte direita da figura.

Neste problema, dados os valores B e T, seu programa deve computar quem vai ficar com o pedaço que vale 100 reais, ou se o valor da nota se perdeu.

Solução:

A lógica desse problema é simples. Após ler os valores, é necessário somá-los e identificar se são maiores que 160 (caso 1), menores (caso 2) ou então a resposta é zero. Também pode ser feito calculando a área cortada, mas isso não é necessário. Eu fiz das duas formas em C, veja abaixo!

Código em C:

Solução 1:

#include <stdio.h> 

int main() {
    int b;
    int t;
    scanf("%d", &b);
    scanf("%d", &t);
    if (b + t > 160)
        printf("1\n");
    else if (b + t < 160)
        printf("2\n");
    else
        printf("0\n");
    return 0; 
}

Solução 2:

#include <stdio.h> 
int main() {
    const double metade = 5600.0;
    double area = 11200.0;
    double h = 70.0;
    double l = 160.0;
    double b;
    double t;
    double areaCortadaEsq;
    scanf("%lf", &b);
    scanf("%lf", &t);
    if (b < t)
        areaCortadaEsq = b * h + ((t - b) * h) / 2;
    else if (b > t)
        areaCortadaEsq = t * h + ((b - t) * h) / 2;
    else
        areaCortadaEsq = t * h;
    if (areaCortadaEsq > metade)
        printf("1\n");
    else if (areaCortadaEsq < metade)
        printf("2\n");
    else
        printf("0\n");
    return 0; 
}

Código em C++:

Código semelhante à solução 1 em C apresentada.

#include <iostream> 

int main() {
    int b;
    int t;
    std::cin >> b;
    std::cin >> t;
    if (b + t > 160)
        std::cout << "1" << std::endl;
    else if (b + t < 160)
        std::cout << "2" << std::endl;
    else
        std::cout << "0" << std::endl;
    return 0; 
}

Código em Haskell:

pegaMaiorParte :: Int -> Int -> Int
pegaMaiorParte a b
   | a + b > 160 = 1
   | a + b < 160 = 2
   | otherwise = 0

main :: IO ()
main = do
   b <- readLn
   t <- readLn
   print (pegaMaiorParte b t)

Espero mais uma vez que tenham gostado! Chave aleatória para doações, caso alguém possa contribuir: 6d8bc7a8-5d74-493a-ab7a-3515baf35956. Agradeço novamente!

URI (BEECROWD) - 1632 - Variations (Variações) - Strings - C, C++ e Haskell

Hoje vamos apresentar a solução do problema Variations (Variações), da categoria Strings no Beecrowd. Não foi um problema difícil de resolver e acho que não terão dificuldades em entender o código :) Confira na sequência como eu resolvi esse problema!

Chave PIX para ajudar o blog: 6d8bc7a8-5d74-493a-ab7a-3515baf35956. 

Plataforma: URI (BEECROWD)

Problema: 1632

Enunciado:

A internet já não é tão segura quanto ela já foi. Um dos sinais disso é o aumento de ataque de hackers a diversos sites. Para piorar, quando um hacker rouba a senha de um usuário em um determinado site, ele tem também acesso a todas as outras contas deste usuário em outros sites, pois a maioria dos usuários hoje em dia usa a mesma senha em todos os sites que acessa.

Uma das soluções propostas para resolver este problema é usar diferentes senhas para cada site, ou até mesmo diferentes variações da mesma senha. Por exemplo, para variar a senha “batata”, é possível usar a senha “bAtaTa”, “B4tat4”, “baTATA”, etc. Ou seja, para cada caractere do alfabeto, é possível formar uma variação colocando tal caractere em maiúsculo ou minúsculo. Inclusive, para aumentar o número total de variações, para os caracteres A, E, I, O e S é possível usar também os números 4, 3, 1, 0 e 5, respectivamente.

Seu amigo precisa aumentar o número de variações de sua senha, e pediu sua ajuda. Dada a senha que ele escolheu, diga o número de diferentes variações que é possível montar.

Linguagem: C, C++ e Haskell

Solução: 

Basicamente a solução passa por verificar qual é o caractere em questão e substituí-lo pelo número correspondente, assim fazendo a multiplicação entre eles para gerar a resposta.

Código em C:

#include <stdio.h>

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

int main() {
    unsigned int n;
    char senha[17];
    char c;
    unsigned int resposta;
    unsigned int i;

    scanf("%u", &n);
    while (n--) {
        scanf("%s", senha);
        resposta = 1;
        for (i = 0; i < obtemTamanho(senha); i++) {
            c = senha[i];
            if (c == 'a' || c == 'A' || c == 'e' || c == 'E' || c == 'i' || c == 'I' || c == 'o' || c == 'O' || c == 's' || c == 'S')
                resposta *= 3;
            else
                resposta *= 2;
        }
        printf("%u\n", resposta);
    }
    return 0; 
}

Código em C++:

O código em C++ segue a mesma lógica do código em C.

#include <iostream> 
#include <string>

int main() {
    unsigned int n;
    std::string senha;
    std::cin >> n;
    while (n--) {
        std::cin >> senha;
        int resposta = 1;
        for (int i = 0; i < senha.size(); i++) {
            char c = senha[i];
            if (c == 'a' || c == 'A' || c == 'e' || c == 'E' || c == 'i' || c == 'I' || c == 'o' || c == 'O' || c == 's' || c == 'S')
                resposta *= 3;
            else
                resposta *= 2;
        }
        std::cout << resposta << std::endl;
    }
    return 0; 
}

Código em Haskell:

Aqui também aplicou-se a mesma lógica, porém de forma recursiva.

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

obtemVariacoes :: [Char] -> Int
obtemVariacoes [] = 1
obtemVariacoes (x:xs)
   | x == 'A' || x == 'a' || x == 'e' || x == 'E' || x == 'i' = 3 * obtemVariacoes xs
   | x == 'I' || x == 'o' || x == 'O' || x == 's' || x == 'S' = 3 * obtemVariacoes xs
   | otherwise = 2 * obtemVariacoes xs

reading :: Int -> IO ()
reading n = do
   if n == 0
      then return ()
      else do
         senha <- getLine
         print (obtemVariacoes senha)
         reading (n-1)

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

URI (BEECROWD) - 1515 - Hello Galaxy - Ad-Hoc - C, C++ e Haskell

Hello Galaxy! Mais um exercício resolvido da categoria Ad-Hoc no Beecrowd. A solução desse exercício é bem simples, bora conferir?

Plataforma: Beecrowd (antiga URI)

Problema: 1515

Enunciado:

Atualmente, no ano de 2114, o conhecimento de que não estamos sozinhos no universo não é novidade, porém um século atrás isto ainda era um mistério. Diversas civilizações na Via Láctea já emitiram algum tipo de sinal provando sua existência, e outras até estabeleceram um contato aberto com a Terra em busca de informações sobre a tal Árvore Hexagonária (afinal, estamos em 2114).

Rafael tem muito interesse pelo assunto, e em um trabalho para a escola se encarregou de descobrir qual foi a civilização mais antiga que enviou um Hello Galaxy para toda a galáxia. Hello Galaxy nada mais é que o primeiro dos passos do Protocolo de Iniciação na Sociedade Via Láctea, PISVL, garantindo que a nova civilização possa entrar em contato com as demais caso necessário.

A mensagem Hello Galaxy traz consigo duas informações básicas: o texto “Hello Galaxy”, que faz parte da tradição, e o nome do planeta da civilização que enviou a mensagem. O CMSVL, Centro de Monitoramento da Sociedade Via Láctea, instalado, por algum motivo, na Terra, recebe tais mensagens, armazenando em um registro o ano em que foi recebida a mensagem e a quantidade de anos que tal mensagem levou para chegar até ali.

A tarefa de Rafael é simples: descobrir quem foi a primeira civilização a enviar a mensagem Hello Galaxy.

Linguagens: C, C++ e Haskell

Solução:

Basta remover o tempo do ano de chegada e verificar qual das entradas resulta em menor valor.

Código em C++:

Coloquei uma variável menor com um número bem grande, de forma que comparada com qualquer valor, na primeira comparação ela vai obter o primeiro valor informado pelo usuário (ano de chegada menos o tempo). Assim, basta fazer o mesmo procedimento de remover o tempo do ano de chegada a cada linha informada e comparar com o valor que está na variável menor. Sempre que essa variável for atualizada, o nome do planeta também precisa ser, pois a resposta será o nome do planeta.

#include <iostream>
#include <string>

using namespace std;

int main() {
    int n;
    while (cin >> n) {
        int menor = 99999;
        int anoChegada;
        int tempo;
        int resultado;
        string planeta;
        string resposta;

        if (!n)
            break;

        for (int i = 0; i < n; i++) {
            cin >> planeta >> anoChegada >> tempo;
            resultado = anoChegada - tempo;
            if (resultado < menor) {
                menor = resultado;
                resposta = planeta;
            }
        }

        cout << resposta << endl;
    }
    return 0;
}

Código em C:

Aqui a mesma lógica foi aplicada.

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

int main() {
    int n;
    int i;
    int anoChegada;
    int tempo;
    int resultado;
    char planeta[55];
    char resposta[55];
    int menor;

    while (scanf("%d", &n) != EOF) {
        menor = 99999;
        if (!n)
            break;

        for (i = 0; i < n; i++) {
            scanf("%s %d %d", planeta, &anoChegada, &tempo);
            resultado = anoChegada - tempo;
            if (resultado < menor) {
                menor = resultado;
                strcpy(resposta, planeta);
            }
        }

        printf("%s\n", resposta);
    }

    return 0;
}

Código em Haskell:

main :: IO ()
main = do
    n <- readLn
    if n == 0
      then return ()
      else do
         obtemResposta n 99999 ""
         main

obtemResposta :: Int -> Int -> [Char] -> IO ()
obtemResposta 0 _ p = putStrLn p
obtemResposta n menor p = do
   linha <- getLine
   let [planeta, anoChegada, tempo] = words linha
   let resultado = read anoChegada - (read tempo) :: Int
   if resultado < menor
      then obtemResposta (n-1) resultado planeta
      else obtemResposta (n-1) menor p

Chave PIX (chave aleatória) para doações: 6d8bc7a8-5d74-493a-ab7a-3515baf35956

Ajude o blog mais uma vez!

URI (BEECROWD) - 3473 - Alerte o Próximo - Ad-Hoc - C, C++ e Haskell

Boa tarde! Esse post eu vou fazer só para deixar aqui registrada a solução vinculada ao exercício Alerte o Próximo, porque na verdade ele já foi resolvido para outro código que tem exatamente o mesmo problema. É um exercício bem fácil, veja abaixo!

Plataforma: URI (BEECROWD)

Problema: 3473

Linguagens: C, C++ e Haskell

Enunciado:

Em um consultório médico, senhas são distribuídas entre os pacientes. Quando o médico chama um paciente pelo número da senha, este alerta o próximo, para que fique na cadeira perto da porta. Agora ele quer que você o ajude nesse processo.

Solução:

Basta somar um ao valor lido!

Código em C:

Ao ler n (inteiro), imprima n+1. Só isso!!!

#include <stdio.h>

int main() { 
    int n;
    scanf("%d", &n);
    printf("%d\n", n + 1);
    return 0;
}

Código em C++:

Aqui se faz a mesma coisa!

#include <iostream>
int main() { 
    int n;

    std::cin >> n;

    std::cout << (n + 1) << std::endl;

    return 0;
}

Código em Haskell:

E aqui em Haskell! Basicamente, criada a função main, é necessário apenas ler o valor de n (fiz isso com readLn) e imprimir n+1. Fiz isso diretamente com print para não precisar usar a função show. Assim o código fica ainda mais simples!

main :: IO ()
main = do
    n <- readLn
    print (n + 1)

Espero que tenham gostado! Chave PIX (chave aleatória) para doações: 6d8bc7a8-5d74-493a-ab7a-3515baf35956. Qualquer valor ajudará muito, obrigado mais uma vez!

Obs.: embora com enunciados um pouco diferentes, esse problema tem exatamente a mesma solução que o problema 2839.

Solução aqui no blog.