Swift Regex for non consecutive numbers and non repeating digits

Question

I'm trying to check for the following considerations in a number of 4 digits, for a PIN number

• No 4 consecutive digits (1234, 2345, etc), upwards or downwards
• Shouldn't start with 19 or 20 to prevent using a year
• Have no more than 2 repeated numbers (1112 wrong, 1122 ok)

I have the equivalent regex made for Android:

"^(?!(.)\\1{3})(?!19|20)(?!0123|1234|2345|3456|4567|5678|6789|7890|0987|9876|8765|7654|6543|5432|4321|3210)\\d{4}\$"

But when I use the same pattern in Swift I get:

Invalid escape sequence in literal

Showing a red mark (underline) below the \ on \$ at the very end.

Removing the \ doesn't work as it matches anything

But I'm also not sure that the exact same pattern can be used for Swift, as I've seen other examples with the same error, but for different reason, there I see they don't use double \\.

For example: Invalid escape sequence in literal with regex

I also created this extension for NSRegularExpression, that I got from Hacking with Swift so that testing was easier.

extension NSRegularExpression {
    func matches(_ string: String) -> Bool {
        let range = NSRange(location: 0, length: string.utf16.count)
        return firstMatch(in: string, options: [], range: range) != nil
    }
}

And this is how my method looks like:

func isValidPIN(_ pin: String) -> Bool {
    let pattern = #"""
        ^(?!(.)\1{3})
        (?!19|20)
        (?!0123|1234|2345|3456|4567|5678|6789|7890|0987|9876|8765|7654|6543|5432|4321|3210)
        \d{4}\z
    """#
    
    let regex = try! NSRegularExpression(pattern: pattern)
    
    return regex.matches(pin)
}

---

Replacing \$ for \\z as suggested in the comments helped removing the error, but it's only matching for consecutive numbers, and using custom delimiters shows these results

• 1234 => Not matching - Should match (4 consecutive numbers)
• 1912 => Not matching - Should match (Starts with 19)
• 1112 => Not matching - Should match (3 repeated numbers)
• 7845 => Not matching - Should not match (Valid pin)

Answer 1

Instead of a giant Regex, I would suggest:

• Define a protocol:

protocol ValidationRule {

    func isValid(for number: Int) -> Bool
}

• Define a String extension to validate a given set of rules:

extension String {

    func isValid(rules: [ValidationRule]) -> Bool {

        guard let number = Int(self) else { return false }

        for rule in rules {

            if !rule.isValid(for: number) { return false }
        }

        return true
    }
}

And then you can implement as many rules as needed. Example:

class FourDigitNumberRule: ValidationRule {
    let allowedRange = 1000...9999
    func isValid(for number: Int) -> Bool {
        return allowedRange.contains(number)
    }
}

class NoConsecutiveDigitsRule: ValidationRule {
    func isValid(for number: Int) -> Bool {
        let coef = 10
        var remainder = number
        var curr: Int? = nil
        var prev: Int? = nil
        var diff: Int?

        while remainder > 0 {

            defer { remainder = Int(remainder / coef) }
            prev = curr
            curr = remainder % coef
            guard let p = prev, let c = curr else { continue }
            let lastDiff = diff
            diff = p - c
            guard let ld = lastDiff else { continue }
            if ld != diff { return true }
            if diff != 1 && diff != -1 { return true }
        }
        return false
    }
}

class NotYearRule: ValidationRule {

    func isValid(for number: Int) -> Bool {
        let hundreds = number / 100
        if hundreds == 19 || hundreds == 20 {
            return false
        }
        return true
    }
}

class NonRepeatRule: ValidationRule {

    func isValid(for number: Int) -> Bool {
        let coef = 10
        var map = [Int: Int]()
        for i in 0...9 {

            map[i] = 0
        }
        var remainder = number
        while remainder > 0 {
            let i = remainder % coef
            map[i]! += 1
            remainder = Int(remainder / coef)
        }
        for i in 0...9 {
            if map[i]! > 2 { return false }
        }
        return true
    }
}

And then use it like this:

let rules: [ValidationRule] = [ FourDigitNumberRule(), NoConsecutiveDigitsRule(), NotYearRule(), NonRepeatRule() ]
string.isValid(rules: rules)

Test:

let rules: [ValidationRule] = [ FourDigitNumberRule(), NoConsecutiveDigitsRule(), NotYearRule(), NonRepeatRule() ]
var test = [ "1234", "1912", "1112", "7845", "274", "14374" ]
for string in test {
    let isValid = string.isValid(rules: rules) ? "valid" : "invalid"
    print("\(string) is \(isValid)")
}

Output:

1234 is invalid
1912 is invalid
1112 is invalid
7845 is valid
274 is invalid
14374 is invalid

Advantages: this provides a better maintainability, and is easier to read than a giant regex you already have trouble writing and understanding... Plus you can use the same approach for any other validation you may ever need.