dev.to staff

Posted on

# 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!

## Top comments (15)

Jan van Brügge

simple Haskell solution:

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

Jan van Brügge

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

Thread

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.

Amin • Edited

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?

Jan van Brügge

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

Ed Reeseg • Edited

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.

erezwanderman

Javascript:

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

Ed Reeseg

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.