How do you tell if unicode letters are sequential in Java?

Question

The general requirment is that I need to implement a method for passwords that does not accept three sequential letters or numbers - so no 'abc123' passwords.

I need a way to see if three letters are sequentially after each other - obviously with any single language this is fairly simple, but a general purpose code for every unicode language seems to escape me.

I assume first I would need a method of figuring out if the three characters are in the same language, and then figure out if they are sequentially after each other. In unicode, there are also languages that are not ordered in any particular way - so there would need to be a way to tell if we were in a language that had order or not.

Is this as complicated as I'm imagining, or are there Java libraries / inherent patterns within unicode that allow something like this?

If I were to reduce the requirements, so that I would just numerically compare the unicode numbers to each other, are there any real world scenarios that I would run into trouble with? i.e. is it likely that someone would choose a password that contained the two ending letters of one language and the first of the next, in a valid way?

Answer 1

If I were you I would get the unicode position of the char and check if the next character has position of the first + 1 - This should work for all languages since Unicode code points should be sorted.

Answer 2

Probably Character.isLetter(c) fits your needs. The following unittest runs trough.

package snippets;

import static org.junit.Assert.*;

public class LetterTest {

    @Test
    public void test3Uni() throws Exception {
        String s = "汉语漢語";
        for (char c : s.toCharArray()) {
            assertTrue(Character.isLetter(c));
        }
    }

}

There is a Character.isDigit(d) too.

Answer 3

You could do search whether there are 3 consecutive code points that are in the same Unicode block. With an extra condition isLetterOrDigit(cp).

Character.UnicodeBlock oldBlock = 0;
int oldCp = 0;
int n = 0;
for (int i = 0; i < s.length(); ) {
    int cp = s.codePointAt(i);
    i += Character.charCount(cp);
    Character.UnicodeBlock block = Character.UnicodeBlock.of(cp);
    if (n != 0 && block == oldBlock && cp == oldCp + 1 && isLetterOrDigit(cp)) {
        ++n;
        oldCp = cp;
        if (n >= 0) {
            return false;
        }
    } else {
        n = isLetterOrDigit(cp) ? 1 : 0;
        oldCp = cp;
        oldBlock = block;
    }
}
return true;

Answer 4

This is not a meaningful requirement.

First off, even if it were possible to define an absolute sequence of every code point, Unicode is a moving target. New code points are added into the unassigned gaps with every release.

From the Unicode Collation Algorithm Introduction:

Collation varies according to language and culture: Germans, French and Swedes sort the same characters differently.

Unicode defines a default sort order, but it may defy user expectations. An English speaker would consider stu to be a consecutive sequence. But consider U+00DF sharp s ß. If you include this in a string and sort using English locale Java collation rules you will end up with sßtu.

The introduction goes on to say:

For scripts and characters not used in a particular language, explicit rules may not exist. For example, Swedish and French have clearly specified, distinct rules for sorting ä (either after z or as an accented character with a secondary difference from a), but neither defines the ordering of characters such as Ж, ש, ♫, ∞, ◊, or ⌂.

You cannot expect a single ordering to be meaningful to every user because of i18n concerns. The best you can do is build a few heuristics for individual languages.