URI (BEECROWD) - 1017 - Fuel Spent (Gasto de Combustível) - Iniciante - Haskell

Buenas! Aqui estamos novamente para resolver um exercício do Beecrowd! Fazia algum tempinho que eu não aparecia aqui devido a outros compromissos, mas vamos lá!

Hoje o problema resolvido é o 1017. Esse problema já foi resolvido aqui no blog nas linguagens C e C++, mas agora resolvi ele na linguagem Haskell. Confira nesse post como foi feita essa nova solução!

Aí está!

Plataforma: URI (BEECROWD)

Problema: 1017

Enunciado:

Joaozinho quer calcular e mostrar a quantidade de litros de combustível gastos em uma viagem, ao utilizar um automóvel que faz 12 KM/L. Para isso, ele gostaria que você o auxiliasse através de um simples programa. Para efetuar o cálculo, deve-se fornecer o tempo gasto na viagem (em horas) e a velocidade média durante a mesma (em km/h). Assim, pode-se obter distância percorrida e, em seguida, calcular quantos litros seriam necessários. Mostre o valor com 3 casas decimais após o ponto.

Solução:

Esse problema foi bem simples de resolver. É necessário ler o tempo decorrido (spentTime) e a velocidade média (averageSpeed), ambos como IO Double. Após isso, precisamos calcular a resposta, que deve ser spentTime * averageSpeed / 12.0. No entanto, é necessário formatar a saída, e para isso usa-se printf. printf é usada de forma parecida com a forma da linguagem C, mas sem parênteses. O importante aqui é usar %.3f para utilizar três casas decimais. E aí, achou fácil também esse exercício?

import Text.Printf (printf)

main :: IO ()
main = do 
   spentTime <- readLn :: IO Double
   averageSpeed <- readLn :: IO Double
   printf "%.3f\n" (spentTime * averageSpeed / 12.0)

URI (BEECROWD) - 3162 - Space Communication (Comunicação Espacial) - Iniciante - Haskell

Buenas!

Cá estou para apresentar mais um problema resolvido!

Foi resolvido agora o problema "Comunicação Espacial". Esse problema é relativamente novo na plataforma e não tem muitas soluções, pelo menos até agora. Eu, inclusive, ainda não o resolvi em outras linguagens, fiz ele só em Haskell por enquanto. Veja na sequência desse post como eu fiz para resolvê-lo!

Porém, como costumo indicar em alguns posts, recomendo que antes de resolver qualquer algoritmo do BEECROWD você siga os seguintes passos:

1. Leia todo enunciado do problema.
2. Leia os tópicos do fórum em caso de dúvidas. As vezes os outros usuários podem esclarecer questões interpretativas e fornecer casos de teste interessantes ou outras dicas valiosas.
3. Prepare arquivos de entrada para teste, considerando as entradas de exemplo do Beecrowd, do udebug e outros valores limite;
4. Prepare o ambiente de desenvolvimento e utilize os mesmos parâmetros dos compiladores do Beecrowd
5. Prepare um código-fonte padrão, já contendo a chamada às bibliotecas padrão, pré-processadores, retorno de função e um comando de escrita com "\n", pois no Beecrowd a grande maioria dos problemas exige a quebra de linha final.

Plataforma: BEECROWD

Problema: 3162

Enunciado:

O ano é 2337. Milhares de naves de tripulações humanas viajam pelo espaço de forma alucinada para lá e para cá. E o melhor: as naves conseguem se comunicar através de rádio, é possível até mesmo que tripulações entre naves distintas jogarem truco.

No entanto, infelizmente a qualidade do sinal esvanece com a distância. Enquanto naves próximas conseguem se comunicar bem, as naves que estão distantes possuem péssima intensidade de sinal para se comunicar. Por esse motivo, as naves comunicam-se preferencialmente com a nave mais próxima.

Considerando um trecho do espaço onde as naves podem ser consideradas pontos no espaço, portanto com coordenadas tridimensionais, com cada eixo podendo ter valor entre 0 e 100 u.m. Sabe-se que a intensidade do sinal de comunicação se dá pela distância entre as naves; de modo que naves que distam entre si até 20 u.m. possuem uma intensidade alta; acima de 20 u.m. e até 50 u.m. possuem uma intensidade média; enquanto a intensidade do sinal acima de 50 u.m. é tão baixa que não possibilita a comunicação entre as naves.

Dadas as informações passadas, ajude os tripulantes destas naves a conseguirem saber a intensidade do sinal entre cada uma delas e a nave mais próxima, para informá-los se eles vão conseguir ter uma boa comunicação entre si.

Linguagem: Haskell

Solução:

A ideia é ler as coordenadas e salvá-las em listas de inteiros, o que é feito com a função replicate monádica. Depois disso, cria-se uma lista contendo a distância de cada ponto com os demais (ok, tive preguiça e calculei distâncias duplicadas, com certeza não precisava disso). O cálculo da distância em R3 é o mesmo que já aprendemos na matemática no ensino médio, é necessário somar o quadrado da diferença de cada eixo e tirar a raiz disso.

Depois, o que fiz foi ordenar as listas de distâncias e pegar sempre a segunda distância, pois a primeira será zero (distância de um ponto até ele mesmo). Ao pegar o segundo elemento de cada lista de distâncias, basta verificar se ele se enquadra em intensidade alta, baixa ou média com base em cada condição e imprime A, B ou M  para cada caso.

Usei a função map monádica sem retorno (mapM_) para imprimir a resposta porque assim ela é fácil de usar e estou interessado somente no efeito que é produzido (escrita na tela), e não no resultado.

Eu mesmo cheguei a criar outras soluções para esse exercício, mas dessa vez vou deixar só essa aqui.

E aí, conseguiu entender?

Código em Haskell:

import Control.Monad (mapM_, replicateM)
import Data.List (sort)

getDistance :: [Double] -> [Double] -> Double
getDistance (x1:y1:z1:[]) (x2:y2:z2:[]) = sqrt ((x1-x2)^2 + (y1-y2)^2 + (z1-z2)^2)

getAllDistances :: [[Double]] -> [Double] -> [Double]
getAllDistances [] _ = []
getAllDistances (l:ist) point = getDistance l point : getAllDistances ist point

getAns :: [Double] -> [Char]
getAns list
   | list!!1 < 20 = "A"
   | list!!1 <= 50 = "M"
   | otherwise = "B"

main :: IO ()
main = do
   n <- readLn
   coord <- replicateM n (do
      line <- getLine
      let xyz = map read (words line) :: [Double]
      return (xyz))
   let values = map (getAllDistances coord) coord
   let sorted = map sort values
   let ans = map getAns sorted
   mapM_ putStrLn ans

Ajude o blog a continuar postando respostas para ajudar a todos com exercícios de programação! A chave aleatória (PIX) para doações é 6d8bc7a8-5d74-493a-ab7a-3515baf35956.

Um abraço a todos!

URI (BEECROWD) - 1016 - Distance (Distância) - Iniciante - Haskell

Novo desafio resolvido em Haskell! O problema n. 1016 é o problema da distância (título Distance/Distância).

Esse exercício é muito fácil de se resolver e serve mais para quem quer se familiarizar com a linguagem ou está dando os primeiros passos em programação.

Vamos ver como resolvi esse exercício? As informações sobre ele estão abaixo, na sequência desse post.

Plataforma: URI (BEECROWD)
Problema: 1016

Enunciado:
Two cars (X and Y) leave in the same direction. The car X leaves with a constant speed of 60 km/h and the car Y leaves with a constant speed of 90 km / h.

In one hour (60 minutes) the car Y can get a distance of 30 kilometers from the X car, in other words, it can get away one kilometer for each 2 minutes.

Read the distance (in km) and calculate how long it takes (in minutes) for the car Y to take this distance in relation to the other car.

Linguagem: Haskell

Solução:

Basicamente precisamos apenas dobrar a distância e assim teremos os minutos necessários.

Nosso código precisa estar na função principal, que é chamada de main. A função main é do tipo IO (). Essa primeira linha é opcional, se não utilizarmos ela o compilador irá inferir o tipo da função.

Na segunda linha iniciamos a função main já colocando o seu código dentro de um bloco do, pois ele é uma sequência de duas ou mais instruções.

No nosso bloco do, temos primeiramente a leitura de um valor inteiro, que é a distância. Como este valor é lido pela entrada padrão, utilizamos o tipo IO Int. A linha seguinte já imprime a resposta. Para isso usamos putStrLn, que quebra a linha ao final do texto, e como parâmetro informamos a mensagem no formato "distancia*2 minutos". Para obter o valor certo de distancia*2 (o dobro da distância), precisamos converter o resultado da expressão para String, o que fazemos com a função show().

Obviamente esta resposta não é a única possível; poderíamos ter usado tipo Integer ou mesmo ter resolvido sem multiplicação (distance+distance era uma possibilidade).

E aí? O que achou desta solução?

Veja o código abaixo e até a próxima!

main :: IO ()
main = do 
   distance <- readLn :: IO Int
   putStrLn (show(distance * 2) ++ " minutos")

URI (BEECROWD) - 1015 - Distância Entre Dois Pontos (Distance Between Two Points) - Iniciante (Beginner) - Haskell

Olá,

Hoje vamos dar continuidade aos posts resolvendo problemas do Beecrowd (antigo URI)

Plataforma: BEECROWD
Problema: 1015

Enunciado (em inglês):
Read the four values corresponding to the x and y axes of two points in the plane, p1 (x1, y1) and p2 (x2, y2) and calculate the distance between them, showing four decimal places after the comma, according to the formula:

Distance = ²√((x2 -x1)² + (y2 - y1)²)

Em português:

Leia os quatro valores correspondentes aos eixos x e y de dois pontos quaisquer no plano, p1(x1,y1) e p2(x2,y2) e calcule a distância entre eles, mostrando 4 casas decimais após a vírgula, segundo a fórmula: 

Distancia = ²√((x2 -x1)² + (y2 - y1)²)

Linguagem: Haskell

Solução:

Observando o enunciado, tudo que precisamos fazer é ler essas coordenadas e usar a fórmula acima.

Como as respostas utilizam sempre quatro casas decimais, decidi por usar o printf para melhor formatar esta saída, por isso faço import Text.Printf (printf).

Leio as coordenadas, que são informadas linha a linha, como valores String, portanto, utilizo getLine para ler a linha inteira. Depois, para cada linha, converto ela em uma lista de coordenadas. Como a entrada será composta por dois valores, já chamo a lista da primeira linha convertida de [x1, y1] e a da segunda linha de [x2, y2]. Para ambas utilizei o tipo de ponto flutuante de dupla precisão (Double).

Feita a conversão, basta utilizar o printf para imprimir o valor com quatro casas decimais e sem esquecer de quebrar a linha ao final (formatação "%.4f\n"). O valor que será formatado é exatamente o da fórmula da distância, ou seja, (sqrt((x2-x1)**2 + (y2-y1)**2)).

import Text.Printf (printf)
main :: IO ()
main = do 
   line1 <- getLine
   line2 <- getLine
   let [x1, y1] = map read (words line1) :: [Double]
   let [x2, y2] = map read (words line2) :: [Double]
   printf "%.4f\n" (sqrt((x2-x1)**2 + (y2-y1)**2))

Ajude o blog! O nosso PIX para doações é a chave aleatória 6d8bc7a8-5d74-493a-ab7a-3515baf35956

URI (BEECROWD) - 1014 - Consumption (Consumo) - Iniciante - Haskell

Bom dia!

Hoje vim bem cedo aqui para já postar mais uma solução de exercício em Haskell, essa linguagem funcional que é muito fácil de usar :)

O exercício da vez também é da categoria Iniciante e se chama "Consumption" (Consumo). Nesse exercício a gente trabalha as questões de tipos e formatação de saída. É possível falar que a solução fica, de certa forma, parecida com a solução em C, pois a formatação também pode ser feita com printf, função disponível em C pela biblioteca stdio.

Então, vamos conferir a resposta?

Plataforma: URI / BEECROWD
Problema: 1014

Enunciado:
Calcule o consumo médio de um automóvel sendo fornecidos a distância total percorrida (em Km) e o total de combustível gasto (em litros).

Linguagem: Haskell

Solução:

Aqui foi importante importar a função printf, disponível em Text.Printf, para poder formatar a saída com três casas decimais como pede o exercício. Na nossa função main, lemos os dois valores da entrada padrão com readLn definindo o tipo como IO Double, já que é lido da entrada padrão (stdin) e o valor é um número real.

Com os valores lidos, basta dividir o primeiro valor pelo segundo, formatando o printf com %.3f para delimitar em três casas decimais. Em Haskell há uma limitação na formatação, não aceitando %lf (long float, que seria o double) e aceitando somente %f. Dessa forma, usa-se %.3f e isso resolve o exercício!

import Text.Printf (printf)
main :: IO ()
main = do 
   distance <- readLn :: IO Double
   fuelTotal <- readLn :: IO Double
   printf "%.3f km/l\n" (distance / fuelTotal)

URI (BEECROWD) - 1013 - The Greatest (O Maior) - Iniciante - Haskell

Meus caros!

Vamos resolver aqui um problema novo em Haskell! Não tão novo assim por já ter sido resolvido em C e C++ aqui no blog, mas dessa vez vamos fazer a solução do The Greatest (O Maior) nessa outra linguagem! 

Plataforma: URI (BEECROWD)
Problema: 1013

Enunciado:
Faça um programa que leia três valores e apresente o maior dos três valores lidos seguido da mensagem “eh o maior”. Utilize a fórmula:

MaiorAB = (a+b+abs(a-b))/2

Obs.: a fórmula apenas calcula o maior entre os dois primeiros (a e b). Um segundo passo, portanto é necessário para chegar no resultado esperado.

Linguagem: Haskell

Solução:

Minha estratégia foi declarar uma função exatamente como a definição de MaiorAB. Por estarmos lidando com valores do tipo Int, em vez de usar o operador "/" a gente usa o "div". Assim, montei exatamente a função.

Tendo a definição da função, basta chamá-la para os parâmetros lidos na forma f ( f (a b) c), ou seja, obtenho o maior entre "a" e "b" e este maior será comparado com "c", o que resultará sempre no maior valor.

Como os valores são lidos na mesma linha, li a linha com getLine num primeiro momento para depois separar cada valor em palavras (com a função words) e convertê-los um a um para Int com map read, o que resulta, agora, em uma lista de Int que terá os três valores lidos.

Agora sim, com os valores Int, basta aplicar a função e imprimir com putStrLn o valor convertido para String, usando a função show, e exibindo o restante da mensagem como solicitado no enunciado.

Fácil? Difícil?

maiorAB :: Int -> Int -> Int
maiorAB a b = div (a + b + abs(a-b)) 2

main :: IO ()
main = do 
   line <- getLine
   let [a, b, c] = map read (words line) :: [Int]
   putStrLn (show(maiorAB (maiorAB a b) c) ++ " eh o maior")

URI (BEECROWD) - 1012 - Area (Área) - Iniciante - Haskell

Boa tarde!

Continuando nossa sequência de soluções em Haskell, agora vamos para o problema número 1012 (Área). Um problema parecido com os demais, em que basta ler valores, aplicar uma fórmula e formatar a saída. Novamente, um bom problema para aprender sobre programação, paradigma declarativo e comandos básicos de uma linguagem. Bora ver como se resolve?

Plataforma: Beecrowd (antiga URI)

Problema: 1012

Enunciado:

In english:

Make a program that reads three floating point values: A, B and C. Then, calculate and show:

a) the area of the rectangled triangle that has base A and height C.

b) the area of the radius's circle C. (pi = 3.14159)

c) the area of the trapezium which has A and B by base, and C by height.

d) the area of ​​the square that has side B.

e) the area of the rectangle that has sides A and B.

Linguagem: Haskell

Solução:

Os valores foram lidos como String com getLine, então foram convertidos um a um para Double e armazenados em uma lista de Double. Cada item se chama a, b, c, respectivamente. Para fazer esta conversão entre a linha lida (String) e gerar uma lista de Double ([Double]), basta separar cada "palavra" (conjunto de caracteres delimitados por espaço em branco) da linha lida com a função words. Isso resulta em uma lista de Strings contendo os valores, mas precisamos deles em formato numérico (Double). Assim, aplicamos o mapeamento de read em cada valor da lista de String, dizendo que queremos que o resultado seja do tipo [Double]. Assim, declarando [a, b, c] obtendo o valor de map read (words line) :: [Double] teremos os três valores informados em formato Double, essencial para poder realizar os cálculos que o exercício propõe.

Feito isto, basta aplicar as fórmulas do triângulo, do círculo, do trapézio, do quadrado e do retângulo com os valores informados e exibir na tela com delimitação de três casas decimais.

Como já foi feito em outras soluções aqui no blog, o printf foi utilizado para formatar a saída com %.3f, assim atendendo ao que solicita o enunciado deste problema. Não esqueça que para usar o printf você precisa importá-lo (import Text.Printf).

import Text.Printf (printf)

main :: IO ()
main = do 
   line <- getLine
   let [a, b, c] = map read (words line) :: [Double]

   printf "TRIANGULO: %.3f\n" (a * c / 2)
   printf "CIRCULO: %.3f\n" (3.14159 * c * c)
   printf "TRAPEZIO: %.3f\n" ((a + b) * c / 2)
   printf "QUADRADO: %.3f\n" (b * b)
   printf "RETANGULO: %.3f\n" (a * b)

Aqui no blog esse exercício também foi resolvido em outras linguagens. Você pode procurar pelo marcador "1012" e irá encontrar.

PIX para doações: 6d8bc7a8-5d74-493a-ab7a-3515baf35956

Ajude-nos para que as postagens sigam acontecendo!

URI (BEECROWD) - 1011 - Sphere (Esfera) - Iniciante - Haskell

Voltando a fazer posts por aqui 😃

Hoje vamos resolver mais um problema de Haskell, o problema Esfera. Mais um da categoria Iniciante, é bem simples e bom para compreender os comandos básicos dessa linguagem declarativa.

Plataforma: Beecrowd (antiga URI)

Problema: 1011

Enunciado:

In english:

Make a program that calculates and shows the volume of a sphere being provided the value of its radius (R) . The formula to calculate the volume is: (4/3) * pi * R3. Consider (assign) for pi the value 3.14159. Tip: Use (4/3.0) or (4.0/3) in your formula, because some languages (including C++) assume that the division's result between two integers is another integer. :)

Linguagem: Haskell

Solução:

Precisamos obter o valor do raio (r) que é informado pelo usuário. Isso é feito usando readLn, e o tipo precisa ser IO Double, pois o raio não é um número inteiro, mas sim de ponto flutuante.

A fórmula a ser utilizada é r**3.0 * 3.14159 * 4.0/3.0. Basta imprimir este valor conforme solicitado no enunciado.

Para imprimir o resultado foi utilizado o printf (não esqueça do import para que esta função funcione), assim fica fácil delimitar as casas decimais. Lembre-se que o %.3f formata o resultado em ponto flutuante com três casas após a vírgula, exatamente como pede o enunciado.

import Text.Printf (printf)
main :: IO ()
main = do 
   r <- readLn :: IO Double
   printf "VOLUME = %.3f\n" (r**3.0 * 3.14159 * 4.0/3.0)

Aqui no blog também está disponível a solução para o problema 1011 em outras linguagens, então se você gosta de programar em linguagens imperativas, também vai encontrar a solução :)

E novamente peço para que ajude o blog, para que eu siga postando aqui respostas em diversas linguagens! Sei que isso ajuda muita gente que está iniciando na programação. O PIX para doações é 6d8bc7a8-5d74-493a-ab7a-3515baf35956. Sua ajuda será muito útil e eu agradeço demais!

URI (BEECROWD) - 1010 - Simple Calculate (Cálculo Simples) - Iniciante - Haskell

Olá!

Hoje vamos voltar a resolver um probleminha em Haskell (Simple Calculate / Cálculo Simples).

Esse exercício é bem fácil e pode ser resolvido com poucas linhas de código. Confira na sequência desse post!

Plataforma: Beecrowd (antiga URI)

Problema: 1010

Enunciado:

In english:

In this problem, the task is to read a code of a product 1, the number of units of product 1, the price for one unit of product 1, the code of a product 2, the number of units of product 2 and the price for one unit of product 2. After this, calculate and show the amount to be paid.

Linguagem: Haskell

Solução:

Precisamos obter os valores digitados em duas linhas. Isso pode ser obtido com getLine, mas o conteúdo da linha estará como String. Assim, para cada linha podemos criar uma lista de valores Double, sendo, em ordem, o código, a quantidade de unidades e o preço. A função read pode fazer essa conversão de String -> Double, mas precisamos que a função read seja passada como parâmetro para a função map, assim ela aplicará a conversão para todas as palavras da linha (por isso o parâmetro deve ser words product1 para a primeira linha e words product2 para a segunda), resultado em uma lista de Double, ou seja, um [Double].

Feito isto, basta calcular o valor total a ser pago, o que é feito obtendo o valor total da primeira linha (quantidade x preço do primeiro produto) e somando este valor ao total da segunda linha (também quantidade x preço, mas do segundo produto).

O resultado deve ser exibido no formato solicitado pelo exercício. Por estarmos trabalhando com valores monetários, o exercício exige a formatação do resultado em duas casas decimais. Para fazer essa formatação basta utilizar o printf e formatar o valor total com %.2f, isso delimita o resultado a duas casas decimais. Não esqueça de importar a função printf!

import Text.Printf (printf)

main :: IO ()
main = do   
   product1 <- getLine
   product2 <- getLine
   let [cod1, units1, price1] = map read (words product1) :: [Double]
   let [cod2, units2, price2] = map read (words product2) :: [Double]
   let total = units1 * price1 + units2 * price2
   printf "VALOR A PAGAR: R$ %.2f\n" (total)

Veja também aqui no blog a solução para o problema 1010 em outras linguagens!

Ah, só mais uma coisa: ajude mais uma vez o blog para que eu continue postando respostas em diversas linguagens! Segue novamente o PIX para doações é 6d8bc7a8-5d74-493a-ab7a-3515baf35956. Sua ajuda será muito útil. 

Um abraço e até a próxima!

URI (BEECROWD) - 1009 - Salary with Bonus (Salário com Bônus) - Iniciante - Haskell

Boa tarde!

Aproveitando esta leva de postagens sobre Haskell, agora vamos apresentar a solução do problema Salary with Bonus (salário com bônus). Esse problema segue a mesma linha do anterior, sendo bom para trabalhar a lógica e encontrar a fórmula necessária para realizar o cálculo correto. Veja na sequência deste post como eu fiz para resolvê-lo, e fique à vontade para expor sua solução nos comentários!

Plataforma: Beecrowd (antiga URI)

Problema: 1009

Enunciado:

In english:

Make a program that reads a seller's name, his/her fixed salary and the sale's total made by himself/herself in the month (in money). Considering that this seller receives 15% over all products sold, write the final salary (total) of this seller at the end of the month , with two decimal places.

- Don’t forget to print the line's end after the result, otherwise you will receive “Presentation Error”.

- Don’t forget the blank spaces.

Linguagem: Haskell

Solução:

Resolvi este exercício primeiramente importando a função printf, pois ela facilita a exibição dos resultados com a delimitação de casas decimais, como é o caso do valor que precisamos. Nossa resposta é um valor monetário, então precisamos que os valores estejam formatados com duas casas decimais.

Após importar o printf, definimos nossa função main e lemos os três valores necessários. O primeiro (sellerName) é uma string, então se lê a linha inteira com getLine. O segundo e o terceiro são valores monetários, então lemos como número de ponto flutuante de dupla precisão (Double). Depois, para calcular o salário total do funcionário, basta fazer o cálculo do salário fixo acrescido da comissão pelas vendas. Esta comissão é de 15% sobre o total de vendas, portanto, total * 0.15 nos dará esse valor. Basta somar isso ao salário fixo e temos a resposta, que precisa ser formatada como o exercício pede, incluindo a quebra de linha (\n) no fim.

E aí, achou fácil?

import Text.Printf (printf)
main :: IO ()
main = do 
   sellerName <- getLine
   fixedSalary <- readLn :: IO Double
   totalSales <- readLn :: IO Double
   printf "TOTAL = R$ %.2f\n" (fixedSalary+(0.15*totalSales))

Em outras soluções aqui do blog você pode verificar outras formas de formatar a saída ou de realizar os cálculos. Dessa vez eu resolvi dessa forma, já colocando diretamente a expressão necessária para obter a resposta dentro do printf. Fique à vontade para fazer do seu jeito!

Ajude este blog! O PIX para doações é 6d8bc7a8-5d74-493a-ab7a-3515baf35956.

URI (BEECROWD) - 1008 - Salary (Salário) - Iniciante - Haskell

Buenas, pessoal!

Resolvi aqui o problema "Salário" (Salary). Esse foi bem fácil, só tem que tomar cuidados com espaços, quebras de linha e delimitação de casas decimais para não deixar de receber o "accepted". Vamos conferir como eu fiz este código?

Plataforma: Beecrowd (antiga URI)

Problema: 1008

Enunciado:

In english:

Write a program that reads an employee's number, his/her worked hours number in a month and the amount he received per hour. Print the employee's number and salary that he/she will receive at end of the month, with two decimal places.

Don’t forget to print the line's end after the result, otherwise you will receive “Presentation Error”.

Don’t forget the space before and after the equal signal and after the U$.

Linguagem: Haskell

Solução:

Basta ler os três valores conforme dito no enunciado e depois formatar a saída como o solicitado. Eu fiz dois comandos de escrita, um putStrLn para a primeira linha, que é NUMBER = numero-do-empregado, e um printf para imprimir SALARY = U$ valor, com delimitação de duas casas decimais.

Um ponto importante neste exercício é que o enunciado menciona a necessidade de ler dois valores inteiros e um de ponto flutuante. No entanto, se você utilizar IO Int para "workedHours", verá que ocorrerá um erro. Isto acontece porque o Haskell tem um sistema de tipos fortemente tipado e não permite a operação entre Int e Double

Meu código acabou ficando assim:

import Text.Printf (printf)
main :: IO ()
main = do 
   employeeNumber <- readLn :: IO Int 
   workedHours <- readLn :: IO Double
   amountPerHour <- readLn :: IO Double

   putStrLn ("NUMBER = " ++ show(employeeNumber))
   printf "SALARY = U$ %.2f\n" (workedHours*amountPerHour)

Assim como em outras soluções que postei aqui, você pode usar let aqui e já calcular o salário antes do printf. Eu preferi fazer já no mesmo comando.

Mais uma fez peço que ajude este blog! O PIX para doações é 6d8bc7a8-5d74-493a-ab7a-3515baf35956

Valeu!

URI (BEECROWD) - 1007 - Difference (Diferença) - Iniciante - Haskell

Buenas, pessoal!

Hora de resolver o problema "Diferença" (difference) do URI/Beecrowd em Haskell. É um problema bem simples, na mesma linha dos outros problemas iniciantes. Veja abaixo como fica a resposta!

Plataforma: Beecrowd (antiga URI)

Problema: 1007

Enunciado:

In english:

Read four integer values named A, B, C and D. Calculate and print the difference of product A and B by the product of C and D (A * B - C * D).

Em português:

Leia quatro valores inteiros nomeados A, B, C e D. Calcule e imprima a diferença do produto de A e B pelo produto de C e D (A * B - C * D).

Linguagem: Haskell

Solução:

Basta ler quatro inteiros (a, b, c, d) com readLn e definindo o tipo como IO Int e depois usar o putStrLn para colocar em tela uma mensagem como o exercício manda: "DIFERENCA = valor". No lugar de valor devemos colocar a expressão a*b - c*d. Dentro da função putStrLn precisamos converter o resultado dessa expressão para string, pois putStrLn coloca string na tela. Então precisamos da função show. O operador ++ faz a concatenação das listas "DIFERENCA = " com a lista que contém os caracteres da resposta de a*b - c*d, pois após a conversão a nossa resposta vira uma lista de caracteres (string).

O código fica da seguinte maneira:

main :: IO ()
main = do
   a <- readLn :: IO Int
   b <- readLn :: IO Int
   c <- readLn :: IO Int
   d <- readLn :: IO Int
   putStrLn ("DIFERENCA = " ++ show(a*b - c*d))

Se você preferir, também pode utilizar let nessa solução. Caso tenha dúvidas sobre como fazer isso, você pode consultar outros posts sobre Haskell ou deixar um comentário que eu ajudo a fazer com let!

Ajude o blog! PIX para doações: 6d8bc7a8-5d74-493a-ab7a-3515baf35956

URI (BEECROWD) - 1006 - Average 2 (Média 2) - Iniciante - Haskell

Ajude o blog! PIX para doações: 6d8bc7a8-5d74-493a-ab7a-3515baf35956

Vamos resolver mais um exercício em Haskell! Agora o problema Average 2 (Média 2)! Veja como é fácil resolver problemas utilizando esta linguagem!

Plataforma: Beecrowd (antiga URI)

Problema: 1006

Enunciado:

In english:

Read three values (variables A, B and C), which are the three student's grades. Then, calculate the average, considering that grade A has weight 2, grade B has weight 3 and the grade C has weight 5. Consider that each grade can go from 0 to 10.0, always with one decimal place.

Linguagem: Haskell

Solução:

Esse exercício é bem semelhante ao exercício "Média 1". As diferenças são:

• naquele exercício havia apenas duas variáveis, e aqui há três;
• o peso total no exercício "Média 1" era 11 e aqui é 10. Daria para calcular multiplicando os pesos como diz o exercício e no fim dividindo todos os valores por 10.0. No entanto, achei melhor já multiplicar cada valor lido por "seu_peso/10", ou seja, usando 0.2 no lugar de 2. Assim poupo uma operação no final. Então a fórmula que traz a média correta fica a*0.2 + b*0.3 + c*0.5.
• A quantidade de casas decimais. Aqui usa-se uma casa, então a formatação é %.1f. Utilizei printf devido à facilidade de delimitar casas decimais com esta função.

Veja o código completo abaixo:

import Text.Printf (printf)
main :: IO ()
main = do
   a <- readLn :: IO Double
   b <- readLn :: IO Double
   c <- readLn :: IO Double
   printf "MEDIA = %.1f\n" (a*0.2 + b*0.3 + c*0.5)

URI (BEECROWD) - 1005 - Average 1 (Média 1) - Iniciante - Haskell

Ajude o blog! PIX para doações: 6d8bc7a8-5d74-493a-ab7a-3515baf35956

Vamos resolver mais um exercício em Haskell!

Agora o problema Average 1 (Média 1)! Bora?!

Plataforma: Beecrowd (antiga URI)

Problema: 1005

Enunciado:

In english:

Read two floating points' values of double precision A and B, corresponding to two student's grades. After this, calculate the student's average, considering that grade A has weight 3.5 and B has weight 7.5. Each grade can be from zero to ten, always with one digit after the decimal point. Don’t forget to print the end of line after the result, otherwise you will receive “Presentation Error”. Don’t forget the space before and after the equal sign.

Linguagem: Haskell

Solução:

Aqui para formatar a saída como no exercício, com cinco casas decimais, é útil fazer uso da função printf, com %.5f ela formata com 5 casas decimais após a vírgula.

Eu usei let para guardar o valor do cálculo da média em "media". No entanto, isso não seria necessário. Abaixo fiz os códigos das duas formas, você pode testá-los na plataforma e verá que os dois são aceitos.

Aqui com let:

import Text.Printf (printf)
main :: IO ()
main = do
   a <- readLn :: IO Double
   b <- readLn :: IO Double
   let media = (a * 3.5 + b * 7.5) / 11.0
   printf "MEDIA = %.5f\n" (media)

Aqui sem let:

import Text.Printf (printf)
main :: IO ()
main = do
   a <- readLn :: IO Double
   b <- readLn :: IO Double
   printf "MEDIA = %.5f\n" ((a * 3.5 + b * 7.5) / 11.0)