# Calculate Function to Solve Anagrams and Calculate Perfect Numbers in a Haskell Assignment Solution

July 15, 2024
Dr. Samantha
🇺🇸 United States
Dr. Samantha Bennett holds a Ph.D. in Computer Science from the University of Cambridge and has completed over 800 Haskell assignments with exceptional results. With expertise in Haskell programming, Dr. Bennett specializes in lazy evaluation, strictness annotations, and deep sequencing techniques. Her vast experience and in-depth knowledge make her a valuable resource for students seeking assistance in Haskell assignments.
Key Topics
• Instructions
• Requirements and Specifications
Tip of the day
News

## Instructions

Objective

Write a program to function to solve anagrams and calculate perfect numbers in a haskell assignment solution.

## Requirements and Specifications

Problem 5.6 - define the function perfects that returns all perfect numbers up to and including a given limit.

A number is "perfect" if it is equal to the sum of its factors.

Fizzbuzz is a classic programming challenge were you must convert a sequence of integers to either the integer itself (as a string), the string "fizz" if the integer is divisible by 3, the string "buzz" if the string is divisible by 5, and "fizzbuzz" if the string is divisible by both 3 and 5. Implement fizzbuzz below, using an array comprehension on the sequence of integers 1 up to and including the given integer.

Screenshots of output

Source Code

```module Main where import Autograder import Data.Map.Strict as Map -- imported to use Map in areAnagrams {- HW2 INSTRUCTIONS 1. Update the instance HW1 Solution name function to return your name (as it appears in ICON). 2. For each problem below, delete `undefined` and replace with your solution. If you need a helper function (hint: you probably will for a few of these), make sure it is limited to the context in which it is used. That is, do not create helper functions that are globally visible. -} instance HW2 Solution where -- TODO: Add your name here name a = "Replace with student name" -- You should not need to modify these perfectsSol a x = perfects x fizzbuzzSol a n = fizzbuzz n areAnagramsSol a s1 s2 = areAnagrams s1 s2 balancedParensSol a s = balancedParens s balancedBracketsSol a s = balancedBrackets s maybeHeadSol a xs = maybeHead xs maybeTailSol a xs = maybeTail xs eitherHeadSol a xs = eitherHead xs eitherTailSol a xs = eitherTail xs {- (P1) Problem 5.6 - define the function perfects that returns all perfect numbers up to and including a given limit. A number is "perfect" if it is equal to the sum of its factors. Ex. 1) factors 6 = [1, 2, 3], sum [1, 2, 3] = 6 therefore 6 is perfect Ex. 2) factors 28 = [1, 2, 4, 7, 14], sum [1, 2, 4, 7, 14] = 28 therefore 28 is perfect Ex. 3) factors 8 = [1, 2, 4], sum [1, 2, 4] = 7 therefore 8 is _not_ perfect Example evaluation of this function (from the book) perfects 500 = [6, 28, 496] -} -- ********** perfects :: Integral b => b -> [b] perfects m = Prelude.filter perfect [3..m] where perfect n = sum (getFactors n) == n -- is perfect if sum of factors equals the number getFactors n = [i | i <- [1..(n `div` 2)], n `mod` i == 0] {- (P2) Fizzbuzz is a classic programming challenge were you must convert a sequence of integers to either the integer itself (as a string), the string "fizz" if the integer is divisible by 3, the string "buzz" if the string is divisible by 5, and "fizzbuzz" if the string is divisible by both 3 and 5. Implement fizzbuzz below, using an array comprehension on the sequence of integers 1 up to and including the given integer. -} fizzbuzz :: (Integral b, Show b) => b -> [String] fizzbuzz n = [if (zmod i 3) || (zmod i 5) then (fb i 3) ++ (fb i 5) else (show i) | i <- [1..n]] where fb m x | x == 3 && (zmod m 3) = "fizz" | x == 5 && (zmod m 5) = "buzz" | otherwise = "" zmod a b = (a `mod` b) == 0 {- (P3) Determine if two strings are anagrams. Hint: use Haskell's Data.Map.Strict data structure -} areAnagrams :: String -> String -> Bool areAnagrams s1 s2 = isAnagram s1 (fromList (zip s2 s2)) where isAnagram [] m = Map.null m isAnagram (x:xs) m = if member x m then isAnagram xs (delete x m) else False {- (P4) Given a string of parentheses, determine if they are balanced. ()() -> balanced (True) ((()())) -> balanced (True) )( -> unbalanced (False) ())() -> unbalanced (False) -} balancedParens :: String -> Bool balancedParens xs = balanced xs [] where balanced [] xs = Prelude.null xs -- no chars in input, no pending closings balanced (x:xs) ys | x == '(' = balanced xs (')':ys) -- add pending closing and recurse with tail -- remove one pending closing and recurse with tail | otherwise = if Prelude.null ys || (head ys) /= x then False else balanced xs (tail ys) {- (P5) Similar to [[balancedParens]], but this time the input can contain parentheses, curly brackets, and square brackets. ()[]{} -> balanced (True) ({}[]) -> balanced (True) ([)] -> unbalanced (False) ([[]) -> unbalanced (False) -} balancedBrackets :: String -> Bool balancedBrackets xs = balanced xs [] where balanced [] xs = Prelude.null xs -- no chars in input, no pending closings balanced (x:xs) ys | x == '(' = balanced xs (')':ys) -- add pending closing and recurse with tail | x == '{' = balanced xs ('}':ys) -- add pending closing and recurse with tail | x == '[' = balanced xs (']':ys) -- add pending closing and recurse with tail -- remove one pending closing and recurse with tail | otherwise = if Prelude.null ys || (head ys) /= x then False else balanced xs (tail ys) {- (P6) Implement the function maybeHead so that it returns a Maybe containing either the head of the list if it exists, otherwise Nothing. -} maybeHead :: [a] -> Maybe a maybeHead [] = Nothing maybeHead (x:xs) = Just x {- (P7) Implement the function maybeTail so that it returns a Maybe containing either the head of the list if it exists, otherwise Nothing. -} maybeTail :: [a] -> Maybe [a] maybeTail [] = Nothing maybeTail (x:xs) = Just xs {- (P8) Implement eitherHead so that it returns an Either containing the head of the list if it exists, otherwise a string describing the error. -} eitherHead :: [a] -> Either String a eitherHead [] = Left "empty" eitherHead (x:xs) = Right x {- (P9) Implement eitherTail so that it returns an Either containing the tail of the list if it exists, otherwise a string describing the error. -} eitherTail :: [a] -> Either String [a] eitherTail [] = Left "empty" eitherTail (x:xs) = Right xs main = do let s = Student "Your name here" autograde s ```

## Related Samples

Explore our free Haskell assignment samples for a clear perspective on functional programming. These samples provide detailed solutions and practical examples, showcasing the application of Haskell in different scenarios. Ideal for students seeking to grasp complex concepts, our samples offer valuable insights and a solid foundation in Haskell programming. Use these resources to navigate your assignments with confidence and achieve academic success.