CODEWITHSUNDEEP
haskellchartuples
James
James

Reputation: 161

List of Pairs of Chars in Haskell?

Is there a function in Haskell where say if you supplied a Char, and a List of 13 Pairs of Chars (all different i.e. every letter of the alphabet was used once and only once) it would return you the Char which is paired with your inputted Char i.e. if I inputted the following:

pairedChar Q [(A,Z),(B,Y),(C,X),(D,W),(E,V),(F,U),(G,T),(H,S),(I,R),(J,Q),(K,P),(L,O),(M,N)]

I would like it to return J?

If there isn't a function like that I was thinking maybe of doing it with unzip to get a pair of lists but wasn't sure what to do with the lists after I get them?

Upvotes: 1

Views: 954

Answers (3)

user2994248
user2994248

Reputation: 1

You could just make a longer list.

alphabet = "ABCDEFGHIJKLMNOPQRTSUVXYZ"

pairs = zip alphabet (reverse alphabet)

theOtherChar k = lookup k pairs --does the job for you now.

Upvotes: 0

Gabriella Gonzalez
Gabriella Gonzalez

Reputation: 35099

This answer builds on itsbruce's answer by still using lookup, but also first massaging the input list to include each pair twice, once for each ordering of elements.

Let's assume that your list is called pairs:

pairs :: [(Char, Char)]
pairs = [('A', 'Z'), ('B', 'Y'), ..., ('M', 'N')]

Then all you need to do is duplicate each pair and swap the elements:

import Data.Tuple (swap)

allPairs :: [(Char, Char)]
allPairs = pairs ++ map swap pairs

-- allPairs = [('A', 'Z') ... ('M', 'N'), ('Z', 'A'), ... ('N', 'M')]

... where swap is a function from Data.Tuple that takes the two elements of a tuple and swaps them. It's defined like this:

swap :: (a, b) -> (b, a)
swap (x, y) = (y, x)

Now you can do a lookup on the allPairs list:

pairedChar :: Char -> Maybe Char
pairedChar c = lookup c allPairs

If you want each duplicate pair to be adjacent to each other in the list, then you can also write allPairs like this:

allPairs = do
    (x, y) <- pairs
    [(x, y), (y, x)]

Now it will contain this ordering:

allPairs = [('A', Z'), ('Z', 'A'), ('B', 'Y'), ('Y', 'B') ... ('M', 'N'), ('N', 'M')]

Upvotes: 2

itsbruce
itsbruce

Reputation: 4843

The lookup function does this; not just for the kind of pairs you describe but for any list of two-element tuples. A list of such tuples is known as an association list, by the way.

It returns a Maybe, because there might beono match.

lookup :: Eq a => a -> [(a, b)] -> Maybe b
lookup key assocs

looks up a key in an association list

Upvotes: 4

Related Questions