How can I pattern match 2 strings in Haskell? Like let's say I have one string which is all the alphabets "ABCDEFGHIJKLMNOPQRSTUVWXYZ" and another string "EKMFLGDQVZNTOWYHXUSPAIBRCJ". It's like a ciphering thing, where I want to pattern match both these strings so that when I type HELLO in plain text using the normal alphabets, I get "QLTTY".
Let's save these strings so we have some convenient names.
a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
b = "EKMFLGDQVZNTOWYHXUSPAIBRCJ"
Now if you zip them together you get a lookup table.
ghci> cypher = zip a b
ghci> cypher
[('A','E'),('B','K'),('C','M'),('D','F'),('E','L'),('F','G'),('G','D'),('H','Q'),('I','V'),('J','Z'),('K','N'),('L','T'),('M','O'),('N','W'),('O','Y'),('P','H'),('Q','X'),('R','U'),('S','S'),('T','P'),('U','A'),('V','I'),('W','B'),('X','R'),('Y','C'),('Z','J')]
You now simply need to map your string to a lookup on this cypher.
map (\ch -> ...) "HELLO"
This should give you a nudge in the right direction.
Related
I'm trying to figure out how I would create variations of a string, by replacing one character at a time in the string with a different character from another array.
For example:
variations = "abc"
getVariations "xyz" variations
Should return:
["xbc", "ybc", "zbc", "axc", "ayc", "azc", "abx", "aby", "abz"]
I'm not quite sure how to go about this. I tried iterating through the string, and then using list comprehension to add the possible characters but I end up losing characters.
[c ++ xs | c <- splitOn "" variations]
Where xs is the tail of the string.
Would someone be able to point me in the right direction please?
Recursively you can define getVariations replacements input
if input is empty, the result is ...
if input is (a:as), combine the results of:
replacing a with a character from replacements
keeping a the same and performing getVariations on as
This means the definition of getVariations could look ike:
getVariations replacements [] = ...
getVariations replacements (a:as) = ...#1... ++ ...#2...
It might also help to decide what the type of getVariations is:
getVariations :: String -> String -> ???
is it possible to get the number of words which contain a specific character from a string ?
for example: string = "yes no maybe"
it would return 2 if the specific character was 'e'.
I have been trying for hours :(
thanks
One way of doing this (shown as a GHCi session) is:
λ> let w = "yes no maybe"
λ> length $ filter (elem 'e') (words w)
2
We split the string into words using the words function.
Then filter the list of words using elem and our chosen character.
Then finally count the number of words that contained the character, using length.
Can also be written as:
length . filter (elem 'e') $ words w
composing the length and filter functions, then applying the combined function to the list of words.
hi am new to Haskell and functional programing..
i want to pass in the string and find the words ending with "ed" or "ing".
eg: if the string is "he is playing and he played well"
answer should be : playing, played
does anyone know how to do this using Haskell.
You can build this using standard Haskell functions. Start by importing Data.List:
import Data.List
Use isSuffixOf to determine if one list ends with another. Below endings could be ["ed","ing"] and w would be the word you're testing, such as "played".
hasEnding endings w = any (`isSuffixOf` w) endings
Assuming you have split the string into a list of individual words (ws below), use filter to eliminate the words you don't want:
wordsWithEndings endings ws = filter (hasEnding endings) ws
Use words to get the list of words from the original string. Use intercalculate to join the filtered words back into the final comma-separated string (or leave this off if you want the result as a list of words). Use . to chain these functions together.
wordsEndingEdOrIng ws = intercalate ", " . wordsWithEndings ["ed","ing"] . words $ ws
And you're done.
wordsEndingEdOrIng "he is playing and he played well"
If you're typing into ghci, put let in front of each of the function definitions (all lines but the last one).
contain w end = take (length end) (reverse w) == reverse end
findAll ends txt = filter (\w -> any (contain w) ends) (words txt)
main = getLine >>= print . findAll ["ing","ed"]
findAll :: [String] -> String -> [String]
findAll :: "endings" -> "your text" -> "right words"
Im learning haskell and I got a problem.
The type must be: sentences :: [String] -> [String]
I want to convert strings into a sentence
["something","","Asd dsa abc","hello world..",""]
to look like this: ["Something.","Asd dsa abc.","Hello world..."]
And I want to use a higher-order function like map.
I just cant figure out how to make this.
I managed to work with a single string:
import Data.Char
sentences :: String -> String
sentences [] = []
sentences (a:as) = (( toUpper a):as) ++ "."
So I get from this:
sentences "sas das asd"
this: "Sas das asd."
I hope someone can help me with this problem.
Thanks for your help!
Edit: Thanks for your help now it looks like this:
import Data.Char
sentences :: [String] -> [String]
sentence (a:as) = ((toUpper a):as)++['.']
sentences = map sentence
But i dont know where to put the filter
Your function coupled with map gets you half of the way, but it does not remove the empty strings from your list of strings. You can do this with filter, so in total
sentences ss = map sentence $ filter (/="") ss
Note that the core of sentences (plural) is simply the mapping of sentence (singular) over your list of strings. The filter is only there to remove the empty strings. Without this requirement, it would simply be sentences ss = map sentence ss.
Now you can call sentences with your list of strings to have each element transformed, except the empty strings that are removed by filter
In general, if you have a function foo that transforms bar into baz, you can use map foo to transform [bar] into [baz]
filter, like map, is a higher order function which, given a predicate function and a list, returns a list consisting of the elements for which the predicate is True. In this case, we give the predicate function (/=""), which is True for all strings that are not empty.
You could also do it with a list comprehension
import Data.Char
capFirst (l:ls) = toUpper l : ls ++ "."
sentences strings = [
capFirst sentence | sentence <- strings,
sentence /= []
]
main = print $ sentences ["something","","Asd dsa abc","hello world..",""]
I have a function, which contains the first 101 characters:
characters :: [String]
characters = [[chr i] |i<-[0..100]]
And what I need to do is to make the next function append to this one permanently, so far I have tried something like this, but this doesn't keep the result.
append :: [String] -> String -> String -> [String]
append characters xs ys = characters ++ [(take 2 (xs++ys))]
So pretty much what I need is to be able to continuously expand my characters function with the append function, and not lose the results.
Thanks for the answers.
Values are immutable in Haskell, so
characters ++ somethingElse
produces a new list, containing a copy of characters at the front, characters itself remains unchanged.
So, as stated, your task is impossible. What are the actual requirements?
I don't know, what you're trying to do with your example. But to answer just your subject, you can import with the hiding-flag and write your own version of a function, like:
import Data.Text hiding (append)
HTH