using System;

using System.Collections.Generic;

using System.Linq;

​

public static class Program

{

    public static void Main()

    {

        Console.WriteLine(IsChecksumCorrect("ZZ0000001535"));

    }

​

        public static bool IsChecksumCorrect(string code, bool reverseLuhn = false, bool allowSymbols = false) {

            try {

                var checksum = ToInt(code.Last());

                return checksum == CalculateChecksum(code.Take(code.Length - 1), reverseLuhn, allowSymbols);

            } catch {

                return false;

            }

        }

        public static int CalculateChecksum(IEnumerable<char> codeWithoutCheckDigit, bool reverseLuhn = false, bool allowSymbols = false) {

            return reverseLuhn

                ? TensComplement(codeWithoutCheckDigit

                    .Select((c, i) => SumDigits(ConditionalMultiplyByTwo(OrdinalPosition(c, allowSymbols), IsOdd(i))))

                    .Sum()

                    )

                : TensComplement(ToDigits(codeWithoutCheckDigit.ToArray(),

                    allowSymbols)

                    .Select((d, i) => SumDigits(ConditionalMultiplyByTwo(d, IsEven(i))))

                    .Sum()

                    );

        }

​

        /// <summary>

        /// Codifica delle lettere secondo la codifica di Luhn , per la specifica validazione dell'algoritmo del CheckDigit. Le cifre rimangono invariate.

        /// </summary>

        /// <param name="c"></param>

        /// <param name="allowSymbols"></param>

        /// <returns></returns>

        private static int OrdinalPosition(char c, bool allowSymbols = false) {

            /* Be careful here. This method is probably inapropriate for anything other than its designed purpose of Luhn-algorithm based validation.

            * Specifically:

            * - numbers are assigned a value equal to the number ('0' == 0, '1' == 1).

            * - letters are assigned a value indicating the number 9 plus the letters ordinal position in the English alphabet ('A' == 10, 'B' == 11).

            * - if symbols are allowed (eg: for CUSIP validation), they are assigned values beginning from 36 ('*' == 36, '@' == 37).

            */

            if (char.IsLower(c))

                return char.ToUpper(c) - 'A' + 10;

​

            if (char.IsUpper(c))

                return c - 'A' + 10;

​

            if (char.IsDigit(c))

                return ToInt(c);

​

            if (allowSymbols)

                switch (c) {

                    case '*':

                        return 36;

​

                    case '@':

                        return 37;

​

                    case '#':

                        return 38;

                }

            throw new ArgumentOutOfRangeException("Specified character is not a letter, digit or allowed symbol.");

        }

​

        private static bool IsEven(this int x) {

            return (x % 2 == 0);

        }

​

        private static bool IsOdd(this int x) {

            return !IsEven(x);

        }

​

        private static int ToInt(this char digit) {

            if (char.IsDigit(digit))

                return digit - '0';

            throw new ArgumentOutOfRangeException("Specified character is not a digit.");

        }

​

        /// <summary>

        /// Conversione dell'array di caratteri secondo la codifica di LUHN e calcolo del modulo.

        /// </summary>

        /// <param name="s"></param>

        /// <param name="allowSymbols"></param>

        /// <returns></returns>

        private static IEnumerable<int> ToDigits(this char[] s, bool allowSymbols = false) {

            var digits = new List<int>();

            for (var i = s.Length - 1; i >= 0; i--) {

                var ordinalPosition = OrdinalPosition(s[i], allowSymbols);

                digits.Add(ordinalPosition % 10);

                if (ordinalPosition > 9)

                    digits.Add(ordinalPosition / 10);

            }

            return digits;

        }

​

        private static int SumDigits(this int value) {

            //return value > 9 ? ((value / 10) + (value % 10)) : value;

            return ((value / 10) + (value % 10));

        }

​

        private static int ConditionalMultiplyByTwo(this int value, bool condition) {

            return condition ? value * 2 : value;

        }

​

        private static int TensComplement(this int value) {

            return (10 - (value % 10)) % 10;

        }

}