2

Ok so i know this is slightly wrong but what am i missing in it? The code is to rotate individual letters in words like:

rotate 1   "hello" "ohell"  
rotate -1  "hello" "elloh"

The code i have is:

module Main where

import System

main = do  
        (arg1:_) <- getArgs  
        xs <- getContents  
        putStr  (rotate xs arg1)  

rotate input w1 = unlines [ process line | line <- lines input ]  
        where process line = unwords [ word | word <- words line ]  
         map rotate n xs = drop n xs ++ take n xs

Is any of this right so far and any clue/tips where to go next?

So a bit more like this:

shift :: a -> Int -> a
rotate :: a -> Int -> a

 x shift i   | i<0       = x shiftR (-i)
             | i>0       = x shiftL i
             | otherwise = x

 x rotate  i | i<0       = rotateR (-i)
             | i>0       = rotateL i
             | otherwise = x
Improve this question
5
  • 1. You need to format this code. 2. what is the definition of f used in the process function? 3. Why are you redefining map? You don't even use the new definition of map. 4. Detailed subjects are good - 'help with haskell' doesn't say anything the tags don't already tell me. Commented Mar 19, 2011 at 19:31
  • I did not notice the f was there as it wasnt sposed to be. In reference to the map i dont fully understand what you mean, i'm new to haskell. Thanks Commented Mar 19, 2011 at 19:41
  • I'd start with separating positive and negative cases of shift, because they have different recursion steps. Think pattern matching, forget the imperative style. The code to rotate elements of a list can be much simpler and use no do at all. Commented Mar 19, 2011 at 19:58
  • 1
    @9000, anon1: Don't treat them separately, just add the length of the list to the negative case, thus making it positive (and semantically equivalent); writing two separate rotations is just ugly. Notice: rotate -1 hello --> elloh and rotate 4 hello --> elloh Commented Mar 19, 2011 at 20:05
  • I do not want to spoil it for you, but look at the following functions: mod, last, init, length. Commented Mar 19, 2011 at 20:53

1 Answer 1

Reset to default
20

The Quick answer:

Try this:

rotate :: Int -> [Char] -> [Char]
rotate x st = take (length st) $ drop (negate x `mod` length st) $ cycle st

It yields:

rotate (1) "hello"
>>> "ohell"
rotate (-1) "hello"
>>> "elloh"

The Explanation:

The insight needed for this to work, is knowledge of the cycle function, which repeats a string forever.

cycle "ezra"
>>> "ezraezraezraezraezr..." (forever)

Using this knowledge, we can exploit length, take, and drop to give us the part of the string that we want. We'll also use negate and mod for the math part.

length

length returns the length of the list (strings are lists of characters). 

length "ezra"
>>> 4

take

take n returns the first n items in a list.

take 9 (cycle "ezra")
>>> "ezraezrae"

drop

drop n returns the whole list, except the first n elements.

drop 3 "ezra"
>>> "a"
drop 3 (take 9 (cycle "ezra"))
>>> "aezrae"

mod

Using the mod function, we can get the proper offsets. The backticks ` make the function "infix", which makes it more understandable. This is the "remainder" after the division, if you're not familiar with modular arithmetic.

10 `mod` 3
>>> 1

This will give us the starting point.

negate

negate n returns the negation of n, which we need to "reverse" the direction, and get the output you wanted.

negate 10
>>> -10

When we put it all together, we get the function above. There are, of course, many ways to do this: this is one.

In my solution above, I developed it in in the following order.

  1. Get the infinite list:

    rotate x st = cycle st

  2. Take the right number of characters:

    rotate x st = take (length st) $ cycle st

  3. Take the characters from the right position:

    rotate x st = take (length st) $ drop (x `mod` length st) $ cycle st

At this point I had what I wanted, but had to add negate so that my output would match yours.

I also added the type signature. I like to have them explicit on as many of my functions as I can.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Seeing as this looked like homework I think providing the full answer is a bit much, but good work on the long explanation.
Thanks for that, it was a great help to creating my own version of this!

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.