Разминка: Luhn algorithm

def check_number(str):
    digits = [int(i) for i in reversed(str)]
   
    double = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]
    ressum = 0
    for i in xrange(0, len(digits), 2):
        try:
            ressum += digits + double[digits[i + 1]]
        except:
            ressum += digits
    #print ressum # for debug
   
    return not (ressum % 10)
   
print check_number("49927398716")
print check_number("49927398717")

Luhn(data : string) : bool {
    def f1(lst) {
        | [] => 0
        | d :: tail => d + f2(tail)
    }
    and f2(lst) {
        | [] => 0
        | d :: tail => (d2 => if (d2 > 9) d2 - 9 else d2) (d * 2) + f1(tail)
    }
    f1(NString.Explode(data ?? string.Empty)
        .Map(c => if(char.IsDigit(c)) (c :> int - '0' :> int)
            else throw ArgumentOutOfRangeException("data", $"Invalid character '$c'."))
        .Reverse()) % 10 == 0
}

Luhn2(data : string) : bool {
    def res = NString.Explode(data ?? string.Empty)
        .FoldRight((false, 0), fun(c, acc) {
            def d = if(char.IsDigit(c)) (c :> int - '0' :> int)
                    else throw ArgumentOutOfRangeException("data", $"Invalid character '$c'.");
            match(acc) {
                | (false, sum) => (true, sum + d)
                | (true, sum) => (false, sum + (d2 => if (d2 > 9) d2 - 9 else d2) (d * 2))
            }
        });
    match(res) {
        | (_, sum) => sum % 10 == 0
    }
}

Luhn3(data : string) : bool {
    def fold(seq) {
        if(seq.MoveNext()) {
            def c = seq.Current;
            def d = if(char.IsDigit(c)) (c :> int - '0' :> int)
                    else throw ArgumentOutOfRangeException("data", $"Invalid character '$c'.");
            match(fold(seq)) {
                | (false, sum) => (true, sum + d)
                | (true, sum) => (false, sum + (d2 => if (d2 > 9) d2 - 9 else d2) (d * 2))
            }
        } else (false, 0)
    }
    match(fold((data ?? string.Empty).GetEnumerator())) {
        | (_, sum) => sum % 10 == 0
    }
}

def check_number(luhnstr):
    assert luhnstr
   
    double = lambda x: [0, 2, 4, 6, 8, 1, 3, 5, 7, 9][x]
   
    def Calc(luhnstr = luhnstr, ressum = 0, func = double):
        if not luhnstr: return ressum
        else:
            func = (lambda x: x) if func == double else double
            return Calc(luhnstr[:-1], ressum + func(int(luhnstr[-1])), func)

    #print Calc() # for debug
   
    return not (Calc() % 10)
   
print check_number("49927398716")
print check_number("49927398717")
print check_number("")

from itertools import cycle

def check_number(luhnstr):
    assert luhnstr
    myiter = cycle([lambda x: x, lambda x: [0, 2, 4, 6, 8, 1, 3, 5, 7, 9][x]])
    return not (sum([myiter.next()(int(i)) for i in reversed(luhnstr)]) % 10)
   
print check_number("49927398716")
print check_number("49927398717")
print check_number("")

def check_number(luhnstr):
    assert luhnstr
   
    funcs = (lambda x: [0, 2, 4, 6, 8, 1, 3, 5, 7, 9][x], lambda x: x)
   
    def Calc(i = -1, ressum = 0):
        if i < -len(luhnstr): return ressum
        else: return Calc(i - 1, ressum + funcs[i % 2](int(luhnstr)))
   
    return not (Calc() % 10)

Luhn4(data : string) : bool {
    def to_digit(c) {
        if(char.IsDigit(c)) (c :> int - '0' :> int)
        else throw ArgumentOutOfRangeException("data", $"Invalid character '$c'.");
    }
    def f1(seq) {
        if(seq.MoveNext()) {
            to_digit(seq.Current) + f2(seq)
        } else 0
    }
    and f2(seq) {
        if(seq.MoveNext()) {
            def d2 = to_digit(seq.Current) * 2;
            (if (d2 > 9) d2 - 9 else d2) + f1(seq)
        } else 0
    }
    def input = data ?? string.Empty;
    def seq = input.GetEnumerator();
    (if(input.Length % 2 == 0) f2(seq) else f1(seq)) % 10 == 0
}

Luhn5(data : string) : bool {
    def to_digit(c) {
        if(char.IsDigit(c)) (c :> int - '0' :> int)
        else throw ArgumentOutOfRangeException("data", $"Invalid character '$c'.");
    }
    def next(seq, s) {
        if(seq.MoveNext())
            s(seq, to_digit(seq.Current))
        else 0
    }
    def s1(seq, d) {
        next(seq, s2) + d
    }
    and s2(seq, d) {
        def d2 = d * 2;
        next(seq, s1) + if (d2 > 9) d2 - 9 else d2
    }
    def input = data ?? string.Empty;
    next(input.GetEnumerator(), if(input.Length % 2 == 0) s2 else s1) % 10 == 0
}

def check_number(luhnstr):
    assert luhnstr    
    funcs = (lambda x: x, lambda x: 2 * x - 9 * (x // 5))
    return sum([funcs[i % 2](int(a)) for i, a in enumerate(reversed(luhnstr))]) % 10 == 0

def luhn(card):
    return not (lambda d: sum(d[::2]) + reduce(lambda s,t: s+sum(divmod(t*2,10)), d[1::2], 0))(map(int, reversed(card))) % 10

print luhn('371449635398431')
print luhn('371449635398432')

def check_number(card):
    #return not (lambda d: sum(d[::2]) + reduce(lambda s,t: s+sum(divmod(t*2,10)), d[1::2], 0))(map(int, reversed(card))) % 10
    return not (lambda d: sum(d[-1::-2]) + sum([sum(divmod(t*2,10)) for t in d[-2::-2]]))(map(int, card)) % 10#


print check_number("49927398716")
print check_number("49927398717")
print check_number('371449635398431')
print check_number('371449635398432')

print check_number("") # oops!