Removing digits from an integer - haskell

Question

Here's a homework problem I came across:
Input an integer, greater than or equal to 0. Multiply it by 5, add 6 to the product, multiply by 4, add 9 and multiply by 5. Then, remove the last two digits of the final number and subtract 1. Output the answer.
Here's my code:
1 main = do
2 putStrLn "enter a non-negative integer: "
3 input <- getLine
4 let i = (read input :: Int)
5 print ((((i * 5) + 6) * 4 + 9) * 5)/100-1
Here, I'm trying to truncate the last two digits by dividing it by 100, since this works in other languages.
However, it gives me this error and I'm not sure what it means:
$ runhaskell Computations.hs
Computations.hs:5:5: error:
• No instance for (Fractional (IO ())) arising from a use of ‘/’
• In the first argument of ‘(-)’, namely
‘print ((((x * 5) + 6) * 4 + 9) * 5) / 100’
In a stmt of a 'do' block:
print ((((x * 5) + 6) * 4 + 9) * 5) / 100 - 1
In the expression:
do { putStrLn "enter a non-negative integer: ";
input1 <- getLine;
let x = (read input1 :: Int);
print ((((x * 5) + 6) * 4 + 9) * 5) / 100 - 1 }
Computations.hs:5:5: error:
• No instance for (Num (IO ())) arising from a use of ‘-’
• In a stmt of a 'do' block:
print ((((x * 5) + 6) * 4 + 9) * 5) / 100 - 1
In the expression:
do { putStrLn "enter a non-negative integer: ";
input1 <- getLine;
let x = (read input1 :: Int);
print ((((x * 5) + 6) * 4 + 9) * 5) / 100 - 1 }
In an equation for ‘main’:
main
= do { putStrLn "enter a non-negative integer: ";
input1 <- getLine;
let x = ...;
.... }
So, can anyone explain what the error means?
Are there any other solutions better than trucating by a divisor?
How can I remove digits at arbitrary positions? For example, remove the first, second and sixth digits from an integer?
ps: input and output should match if done correctly.
Update: I've changed "/" to "div" and it gives me this:
Computations.hs:5:12: error:
• Couldn't match expected type ‘(Integer -> Integer -> Integer)
-> Integer -> Integer’
with actual type ‘Int’
• The function ‘(((i * 5) + 6) * 4 + 9) * 5’
is applied to two arguments,
but its type ‘Int’ has none
In the first argument of ‘(-)’, namely
‘((((i * 5) + 6) * 4 + 9) * 5) div 100’
In the first argument of ‘print’, namely
‘(((((i * 5) + 6) * 4 + 9) * 5) div 100 - 1)’
This part is strange: "The function ‘(((i * 5) + 6) * 4 + 9) * 5’ is applied to two arguments", why does haskell interpret it as a function?

Answer 1

Can anyone explain what the error means?
The precedence in your first line is off - infix functions (like /) usually have a higher precedence than normal ones, so print (...) / 100 is equivalent to (print ...) / 100, which is obviously problematic. You can wrap everything in brackets, or use the $ function:
print $ ((((i * 5) + 6) * 4 + 9) * 5) / 100 - 1
Now as you've constrained i to be an Int, this will still give an error: / is only defined for instances of the Fractional typeclass, and Int isn't. You want integer division, div or quot, which operates only on Integrals (of which Int is an instance) and perform truncation as you want:
print $ ((((i * 5) + 6) * 4 + 9) * 5) `div` 100 - 1
Note the backticks (`), which allow a normal function to be used infix. You could write this as:
print $ (div ((((i * 5) + 6) * 4 + 9) * 5) 100) - 1
But then the brackets are making things really hard to read.
Are there any other solutions better than truncating by a divisor?
In general probably not, but as mentioned on your other question, this particular equation will always give you the same result as your input, so you can just write:
main = getLine >>= print
How can I remove digits at arbitrary positions?
Converting to a string and removing characters is likely your best bet. Something like the following will work, although it's arguably a bit dense:
removeDigits :: [Int] -> Int -> Int
removeDigits indices x = read . reverse . filterIndices indices . reverse . show $ x
filterIndices :: [Int] -> [a] -> [a]
filterIndices inds elems = map snd . filter ((`notElem` inds) . fst) . zip [1..] $ elems
Note this treats the last digit as the "1st" digit - it's a bit more natural to refer to digits with.
An (in my opinion) easier to read representation of your existing code is:
transform = (subtract 1) . (`quot` 100) . (*5) . (+9) . (*4) . (+6) . (*5)
With this way of writing it, composition overrides the arithmetic precedence laws, letting us write it how it's read ("times 5, add 6, times 4, ..."). We have to use subtract 1, as -1 is interpreted as the literal value -1, not as a unary function.

Answer 2

Removing digits at arbitrary positions is an interesting problem. This is probably easiest to do by converting to string and performing string manipulation, then reading back as an Int. Since Int implements both Show and Read, you can do:
type Digit = Int
removeDigits :: [Digit] -> Int -> Int
removeDigits digits = read . go 1 . show
where
go _ [] = []
go i (c:cs) | i `elem` digits = go cs (i+1)
| otherwise = c : go cs (i+1)
-- N.B. I chose 1-indexing here instead of 0-indexing because of your word choice
-- "remove the first, second, and sixth digits" maps naturally to [1, 2, 6],
-- though programmers may find that off-putting. YMMV.
removeDigits here could be re-written as
read [c | (i, c) <- zip [1..] (show n), i `notElem` digits]