# Daily Challenge #103 - Simple Symbols

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!

### Discussion  Jan van Brügge

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

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. Idan Arye

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. Ed Reeseg

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. Ed Reeseg

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. Michael Kohl

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