Daily Challenge #103 - Simple Symbols

dev.to staff on October 31, 2019

Write a function that will take a string and determine if it is an acceptable sequence. The string will be composed of + and = symbols with several... [Read Full]
markdown guide

simple Haskell solution:

verify :: String -> Bool
verify [] = True
verify ('+':x:'+':xs)
    | isLetter x = verify $ '+':xs
verify (x:xs)
    | isLetter x = False
    | otherwise = verify xs

I took your solution and simplified it:

verify :: String -> Bool
verify [] = True
verify ('+':x:'+':xs) = verify $ '+':xs
verify ('+':xs) = verify xs
verify ('=':xs) = verify xs
verify (_) = False

Also note that nothing in the question indicates the characters other than = and + can only be letters. Your version would accept 1 even though 1 is a character and it is not surrounded by +s.


This solution assumes that the only other character is =. No idea if you can assume this

The string will be composed of + and = symbols with several characters between them.

If I'm reading this correctly, it means that the characters are categorized into three categories:

  1. +
  2. =
  3. Other

So any character other than + and = must be surrounded by +s - which is exactly what my version checks.


Whoa, I was comming with something that involved using an indexedMap but your solution is very clever. Thanks for sharing your awesome answer!

Also, isn't isLetter part of Data.Char? Or no need to import that to use the isLetter function?


yes, that function is from Data.Char, I omitted the import together with the module header.


I've never been the best with Regex, but here's a possible attempt:


const acceptableSequence = str => !/(?<!\+)\w|\w(?!\+)/.test(str);

EDIT: Misread the requirements, don't need to account for end and beginning of line characters as exceptions.


\w generally includes the underscore, which is why I used the explicit character class.


That's a good point. I figured I'd use \w since nothing in the challenge indicated that the characters need be only alphabetical, but obviously you could just as easily sub in [a-zA-Z] or whatever fits the use case.

I interpreted “The string will be composed of + and = symbols with several characters between them.” as only +, = and letters. 😀

That definitely makes the most sense, given the examples. I really appreciate you reaching out to clarify - definitely want to make sure I'm accurately hitting objectives.

I'm just assuming either, but at least this is turning into a good lesson on how requirements get confused between whoever plans them and developers 😉



acceptable = str => [...str].every((x, i, a) => x == '+' || x == '=' || (a[i - 1] == '+' && a[i + 1] == '+'))


def verify(s)
  s !~ /(?<!\+)[a-z]|[a-z](?!\+)/

verify "f++d+"
#=> false

verify "++q++qq=z"
#=> false

verify "==++z+=+q+"
#=> true

Here's an alternative version in Raku (formerly Perl6), which IMHO is more readable due to the more expressive lookaround assertions:

sub verify { @_ !~~ /<!after \+><[a..z]>|<[a..z]><!before \+>/ }

verify "f++d+"
# False
verify "++q++qq=z"
# False
verify "==++z+=+q+"
# True
code of conduct - report abuse