An activity I sometimes do when I'm bored is to write a couple of characters in matching pairs. I then draw lines (over the tops never below) to connect these characters. For example I might write $abcbac$ and then I would draw the lines as:

Or I might write $abbcac$

Once I've drawn these lines I try to draw closed loops around chunks so that my loop doesn't intersect any of the lines I just drew. For example, in the first one the only loop we can draw is around the entire thing, but in the second one we can draw a loop around just the $b$s (or everything else)

If we play around with this for a little while we will find that some strings can only be drawn so that closed loops contain all or none of the letters (like our first example). We will call such strings well linked strings.

Note that some strings can be drawn in multiple ways. For example $bbbb$ can be drawn in both of the following ways (and a third not included):

or

If one of these ways can be drawn such that a closed loop can be made to contain some of the characters without intersecting any of the lines, then the string is not strongly linked. (so $bbbb$ is not strongly linked)

Task

Your task is to write a program to identify strings that are well linked. Your input will consist of a string where every character appears an even number of times, and your output should be one of two distinct consistent values, one if the strings are well linked and the other otherwise.

In addition your program must be a well linked string meaning

• Every character appears an even number of times in your program.




• It should output the truthy value when passed itself.

Answers will be scored as their lengths in bytes with fewer bytes being a better score.

Hint

A loop can be drawn around a contiguous substring iff there each character appears an even number of times in that substring.

Test Cases

abcbac -> True

abbcac -> False

bbbb -> False

abacbc -> True

abcbabcb -> True

Jelly, 20 bytes

ĠẈḂẸẆṖÇ€Ạ

ĠẈḂẸ

ẆṖÇ€Ạ

Try it online!

The first line is ignored. It's only there to satisfy the condition that every character appear an even number of times.

The next line first Ġroups indices by their value. If we then take the length of each sublist in the resulting list (Ẉ), we get the number of times each character appears. To check whether any of these are non-even, we get the last Ḃit of each count and ask whether there Ẹxists a truthy (nonzero) value.

Therefore, this helper link returns whether a substring cannot be circled.

In the main link, we take all substrings of the input (Ẇ), Ṗop off the last one (so that we don't check whether the entire string can be circled), and run the helper link (Ç) on €ach substring. The result is then whether Ạll substrings cannot be circled.

Retina, 41 bytes

Lw`.+

N$^`

$.&

0A`

%O`.

(.)1



^.+(¶.+)+$

Try it online! Link includes test cases. Explanation:

Lw`.+

List all of the substrings. (This lists the odd ones as well, but we don't care.)

N$^`

$.&

0A`

Sort the substrings in reverse order of length so that we can remove the original string.

%O`.

Sort the characters in each substring.

(.)1

Remove duplicated characters, thus checking whether they appear an even number of times.

^.+(¶.+)+$

Check whether no substring could be circled.