# Daily Challenge #103 - Simple Symbols

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

Daily Challenge (137 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.

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.

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

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 😉

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 Jun 17

## How to Get Smarter Without Knowing Anything  