# Daily Challenge #103 - Simple Symbols

### dev.to staff twitter logo Oct 31・1 min read

Daily Challenge (120 Part Series)

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 characters between them. For the string to be acceptable, each character must be surrounded by + symbols.

Examples:
(++d+===+c++==a) => false, because a is not surrounded by +.
(+d+e+===+q+=) => true, because all characters are surrounded by +.

Test cases:
"f++d+"
"++q++qq=z"
"==++z+=+q+"

Want to propose a challenge idea for a future post? Email yo+challenge@dev.to with your suggestions!

DISCUSS (15) ``````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:

### JavaScript

``````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 😉

Javascript:

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

Ruby:

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

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
``````
Classic DEV Post from Feb 22

## What are some Browser plugins that you can't live without ? Sore eyes?

dev.to now has dark mode.

Go to the "misc" section of your settings and select night theme ❤️  