using System;

​

namespace ISBNValidator

{

    /// ISBN - International Standard Book Number

    /// -----------------------------------------

    /// There are two ISBN standards: ISBN-10 and ISBN-13.

    /// Support for ISBN-13 is essential, whereas support

    /// for ISBN-10 is optional.

    /// Here are some valid examples of each:

​

    /// ISBN-10:

    /// 0471958697

    /// 0 471 60695 2

    /// 0-470-84525-2

    /// 0-321-14653-0

​

    /// ISBN-13:

    /// 9780470059029

    /// 978 0 471 48648 0

    /// 978-0596809485

    /// 978-0-13-149505-0

    /// 978-0-262-13472-9

​

    /// ISBN-10 is made up of 9 digits plus a check digit (which

    /// may be 'X') and ISBN-13 is made up of 12 digits plus a

    /// check digit. Spaces and hyphens may be included in a code,

    /// but are not significant. This means that 9780471486480 is

    /// equivalent to 978-0-471-48648-0 and 978 0 471 48648 0.

​

    /// The check digit for ISBN-10 is calculated by multiplying

    /// each digit by its position (i.e., 1 x 1st digit, 2 x 2nd

    /// digit, etc.), summing these products together and taking

    /// modulo 11 of the result (with 'X' being used if the result

    /// is 10).

​

    /// The check digit for ISBN-13 is calculated by multiplying

    /// each digit alternately by 1 or 3 (i.e., 1 x 1st digit,

    /// 3 x 2nd digit, 1 x 3rd digit, 3 x 4th digit, etc.), summing

    /// these products together, taking modulo 10 of the result

    /// and subtracting this value from 10, and then taking the

    /// modulo 10 of the result again to produce a single digit.

​

    /// Basic task:

    /// Create a function that takes a string and returns true

    /// if that is a valid ISBN-13 and false otherwise.

​

    /// Advanced task:

    /// Also return true if the string is a valid ISBN-10.

    public class Validator

    {

        public bool IsValidIsbn(string isbn)

        {

            var numericalString = RemoveInsignificantISBNCharacters(isbn);

            var length = string.IsNullOrEmpty(numericalString) ? 0 : numericalString.Length;

​

            switch (length)

            {

                case 10:

                    return IsValidIsbn10(numericalString);

                case 13:

                    return IsValidIsbn13(numericalString);

                default:

                    return false;

            }

        }

​

        /// The check digit for ISBN-10 is calculated by multiplying

        /// each digit by its position (i.e., 1 x 1st digit, 2 x 2nd

        /// digit, etc.), summing these products together and taking

        /// modulo 11 of the result (with 'X' being used if the result

        /// is 10).

        private bool IsValidIsbn10(string s)

        {

            if (string.IsNullOrEmpty(s))

            {

                return false;

            }

            var valid = false;

            foreach (var c in s.Substring(0,s.Length-1))

            {

                valid = char.IsNumber(c);

            }

            var lastChar = s.Substring(s.Length - 1, 1);

            return valid && ComputeIsbn10CheckDigit(s)==lastChar;

        }

​

        private bool IsValidIsbn13(string s)

        {

            if(string.IsNullOrEmpty(s))

            {

                return false;

            }

            var valid = false;

            foreach (var c in s)

            {

                valid = char.IsNumber(c);

            }

            var lastDigit = Convert.ToInt16(s.Substring(s.Length - 1, 1));

            return valid && ComputeIsbn13CheckDigit(s) == lastDigit;

        }

​

        /// The check digit for ISBN-13 is calculated by multiplying

        /// each digit alternately by 1 or 3 (i.e., 1 x 1st digit,

        /// 3 x 2nd digit, 1 x 3rd digit, 3 x 4th digit, etc.), summing

        /// these products together, taking modulo 10 of the result

        /// and subtracting this value from 10, and then taking the

        /// modulo 10 of the result again to produce a single digit.

        private int ComputeIsbn13CheckDigit(string isbn13)

        {

            //look at first 12 chars

            isbn13 = isbn13.Substring(0, isbn13.Length - 1);

            var sum=0;

            for(var i=0; i < isbn13.Length; i++)

            {

                if (i % 2 != 0)

                {

                    sum += Convert.ToInt16(isbn13[i].ToString()) * 3;

                }

                else

                {

                    sum += Convert.ToInt16(isbn13[i].ToString());

                }

            }

            return (10 - sum % 10) % 10;

        }

​

        /// The check digit for ISBN-10 is calculated by multiplying

        /// each digit by its position (i.e., 1 x 1st digit, 2 x 2nd

        /// digit, etc.), summing these products together and taking

        /// modulo 11 of the result (with 'X' being used if the result

        /// is 10).

        private string ComputeIsbn10CheckDigit(string isbn10)

        {

            //look at first 9 chars

            isbn10 = isbn10.Substring(0, isbn10.Length - 1);

            var sum = 0;

            for (var i = 0; i < isbn10.Length; i++)

            {

                sum += Convert.ToInt16(isbn10[i].ToString()) * (i + 1);

            }

            var result = sum % 11;

            return result == 10 ? "X" : result.ToString();

        }

​

        /// ISBN-10 is made up of 9 digits plus a check digit (which

        /// may be 'X') and ISBN-13 is made up of 12 digits plus a

        /// check digit. Spaces and hyphens may be included in a code,

        /// but are not significant. This means that 9780471486480 is

        /// equivalent to 978-0-471-48648-0 and 978 0 471 48648 0.

        private string RemoveInsignificantISBNCharacters(string s)

        {

            return !string.IsNullOrEmpty(s) ? s.Replace(" ", string.Empty).Replace("-", string.Empty) : s;

        }

    }

}

​