How do I check the validity of the Canadian Social Insurance Number in C#?

Question

I've been given the assignment to write an algorithm in C# that checks the validity of a Canadian Social Insurance Number (SIN). Here are the steps to validate a SIN.

Given an example Number: 123 456 782

1. Remove the check digit (the last digit): 123456782
2. Extract the even digits (2,4,6,8th digith): 12345678
3. Double them:

       2  4  6  8
       |  |  |  |
       v  v  v  v
       4  8  12 16 
   

4. Add the digits together:

   4+8+1+2+1+6 = 22

5. Add the Odd placed digits:

       1+3+5+7 = 16

         Total : 38

Validity Algorithm

1. If the total is a multiple of 10, the check digit should be zero.
2. Otherwise, Subtract the Total from the next highest multiple of 10 (40 in this case)
3. The check digit for this SIN must be equal to the difference of the number and the totals from earlier (in this case, 40-38 = 2; check digit is 2, so the number is valid)

I'm lost on how to actually implement this in C#, how do I do this?

Answer 1

Fastest method I've tried so far. No LINQ, no if/else, no odd/even checks, only 1 loop to get an array of integers from the string.

Caveat: no guards - input is assumed to be a string of 9 numbers.

public static bool IsValidSin(string input)
{
    int[] luhnMap = { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 };
    int[] ints = new int[9];
    for (int i = 0; i < 9; i++)
    {
        ints[i] = int.Parse(input[i].ToString());
    }
    int check = ints[0] + luhnMap[ints[1]] + ints[2] + luhnMap[ints[3]] + ints[4] + luhnMap[ints[5]] + ints[6] + luhnMap[ints[7]] + ints[8];
    return (check % 10) == 0;
}

Answer 2

public bool ValidateSIN(string sin)
{        
    if ((int)Char.GetNumericValue(sin[0]) == 0)
    {
        return false;
    }
    else
    {
        string evenString = "";
        int totalOfEvens = 0;
        int totalOfOdds = 0;
        int total, nextMultipleOfTen, remainder;
        int checkDigit = (int)Char.GetNumericValue(sin[8]);

        // multiply each even number of the input string by 2
        // get the resulting numbers into a string so the chars 
        // can be manipulated as individual digits
        for (int i = 1; i <= 7; i += 2)
        {
            evenString += (Char.GetNumericValue(sin[i]) * 2);
        }

        // add the individual digits of the products from the above loop
        foreach (char c in evenString)
        {
            totalOfEvens += (int)Char.GetNumericValue(c);
        }

        // get the odd numbers of the input string, minus the last number,
        // and add them together
        for (int i = 0; i <= 6; i += 2)
        {
            totalOfOdds += (int)Char.GetNumericValue(sin[i]);
        }

        total = totalOfEvens + totalOfOdds;

        // take the quotient of total divided by 10 and add 1 to get the next multiple of ten
        nextMultipleOfTen = (Math.DivRem(total, 10, out remainder) + 1) * 10;

        if ((total % 10 == 0 && checkDigit == 0) || (checkDigit == nextMultipleOfTen - total))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}      

Answer 3

I also recently coded this into an application. Before calling this, the string sSIN has already been checked through regex for being a 9-digit number.

public static bool IsCanadianSocialInsuranceNumber(string sSIN)
    {
        int iChecksum = 0;
        int iDigit = 0;

        for (int i = 0; i < sSIN.Length; i++)
        {
            // even number else odd
            if (((i+1) % 2) == 0)
            {
                iDigit = int.Parse(sSIN.Substring(i, 1))*2;
                iChecksum += (iDigit < 10) ? iDigit : iDigit - 9;
            }
            else
            {
                iChecksum += int.Parse(sSIN.Substring(i, 1));
            }
        }

        return ((iChecksum % 10) == 0) ? true : false;
    }

Answer 4

Here's a very simple way:

int test = 123456782;
if(test > 100000000 && test < 999999999)
{
    int check = test % 10;
    string temp = "";
    foreach(char c in test.ToString().Substring(0, 8))
    {
 //The character codes for digits follow the same odd/even pattern as the digits.
 //This code puts each digit or its value times 2, into a string and sums the digits
 //after instead of keeping 2 separate totals
        if(c % 2 == 1)
        {
            temp += c;
        }
        else
        {
            temp += (int.Parse(c.ToString()) * 2).ToString();
        }
    }
    int temp2 = temp.Sum((x => int.Parse(x.ToString())));
//no need to compare the sum to the next 10, the modulus of 10 will work for this
    int temp2mod = temp2 % 10;
    if((temp2mod == 0 && temp2mod == check) || (10 - temp2mod == check))
        return true;
}
return false;

Answer 5

Search on the internet for "Luhn algorithm". You'll find a lot of examples.

Answer 6

I don't know C# but here is a solution in Python. Maybe you can learn from it the method of how to implement it in C#.

def check(SIN):
    SIN = ''.join(SIN.split(' '))
    if len(SIN) != 9:
        raise ValueError("A Canadian SIN must be 9 digits long")
    check_digit = int(SIN[-1])
    even_digits = [int(SIN[i]) for i in range(1,8,2)]
    odd_digits  = [int(SIN[i]) for i in range(0,8,2)]

    total = sum(i/10 + i%10 for i in map(lambda x: 2*x, even_digits)) + sum(odd_digits)

    if total%10 == 0:
        return check_digit == 0
    else:
        return ((total/10)+1)*10 - total == check_digit

if __name__ == '__main__':
    for SIN in ['123 456 782',
                '123 456 789',
                '046 454 286']:
        print '%s is %sa valid Canadian SIN' % (SIN, '' if check(SIN) else 'NOT ')

which outputs:

123 456 782 is a valid Canadian SIN
123 456 789 is NOT a valid Canadian SIN
046 454 286 is a valid Canadian SIN

Answer 7

The specification you were given makes things a bit more complicated than they need to be: it's actually equivalent and simpler to just add the last digit into the checksum and make sure the checksum's last digit is 0.

The usual trouble new programmers have is "how do I get each digit?" Here's how:

• In integer types, % 10 will delete everything but the last digit of the number: 123 % 10 == 3, and / 10 will delete the last digit of the number: 123 / 10 == 12.
• In strings, str[i] - '0' will give you the digit at index i. The characters for digits are stored as special numbers: '0' is stored as 48 and '9' is stored as 57. If you subtract 48, you'll have the actual digit as a number. You don't really need to memorize "subtract 48", of course: if you just subtract '0', it will do the same thing: '8' - '0' == 8

Here are two efficient methods. One takes an int and checks the checksum of the SIN. One takes a string and checks both the format (must be "ddd ddd ddd") and the checksum of the SIN; though it's pretty efficient, it is a bit ugly and repetitive.

// Checks that the given int is a valid Canadian Social Insurance Number
//   according to both range (000 000 000 to 999 999 998) and checksum.
public static bool IsValidSIN(int sin) {
  if (sin < 0 || sin > 999999998) return false;

  int checksum = 0;
  for (int i = 4; i != 0; i--) {
    checksum += sin % 10;
    sin /= 10;

    int addend = 2*(sin % 10); if (addend >= 10) addend -= 9;
    checksum += addend;
    sin /= 10;
  }

  return (checksum + sin) % 10 == 0;
}

// Checks that the given string is a valid Canadian Social Insurance Number
//   according to both format ("ddd ddd ddd") and checksum.
// Implementation note: uses an admittedly ugly and repetitive parser.
public static bool IsValidSIN(string sin) {
  if (sin.Length != 11) return false;

  int checksum, addend;

  checksum = sin[0] - '0';
  if (checksum < 0 || checksum > 9) return false;

  addend = 2*(sin[1] - '0'); if (addend >= 10) addend -= 9;
  if (addend < 0 || addend > 9) return false;
  checksum += addend;

  addend = sin[2] - '0';
  if (addend < 0 || addend > 9) return false;
  checksum += addend;

  if (sin[3] != ' ') return false;

  addend = 2*(sin[4] - '0'); if (addend >= 10) addend -= 9;
  if (addend < 0 || addend > 9) return false;
  checksum += addend;

  addend = sin[5] - '0';
  if (addend < 0 || addend > 9) return false;
  checksum += addend;

  addend = 2*(sin[6] - '0'); if (addend >= 10) addend -= 9;
  if (addend < 0 || addend > 9) return false;
  checksum += addend;

  if (sin[7] != ' ') return false;

  addend = sin[8] - '0';
  if (addend < 0 || addend > 9) return false;
  checksum += addend;

  addend = 2*(sin[9] - '0'); if (addend >= 10) addend -= 9;
  if (addend < 0 || addend > 9) return false;
  checksum += addend;

  addend = sin[10] - '0';
  if (addend < 0 || addend > 9) return false;

  return (checksum + addend) % 10 == 0;
}

Answer 8

This is a nice problem to solve. This should be more efficient than converting to string and parsing back to integer. This solution will work on .NET 3.5 and later.

    public static IEnumerable<int> ToDigitEnumerable(this int number)
    {
        IList<int> digits = new List<int>();

        while(number > 0)
        {
            digits.Add(number%10);
            number = number/10;
        }

        //digits are currently backwards, reverse the order
        return digits.Reverse();
    }

    public static bool IsCanadianSocialInsuranceNumber(int number)
    {
        var digits = number.ToDigitEnumerable();

        if (digits.Count() != 9) return false;

        //The left side of the addition is adding all even indexes (except the last digit).
        //We are adding even indexes since .NET uses base 0 for indexes

        //The right side of the addition, multiplies the odd index's value by 2, then breaks each result into
        //individual digits, then adds them together
        var total = digits.Where((value, index) => index%2 == 0 && index != 8).Sum()
                    + digits.Where((value, index) => index%2 != 0).Select(v => v*2)
                          .SelectMany(v => v.ToDigitEnumerable()).Sum();

        //The final modulous 10 operator is to handle the scenarios where the total
        //is divisble by 10, in those cases, the check sum should be 0, not 10
        var checkDigit = (10 - (total%10)) % 10;

        return digits.Last() == checkDigit;
    }

One problem with this solution is that it assumes that number, represented as an integer, is 9 digits (can't start with a 0). If the number can start with a 0, then it has to be represented as a string (or converted to a string and padding with zeros). The logic to test will remain mostly intact, but the parts that assume integers will need to be swapped out with strings, and then you'll have to do parsing.

Answer 9

The crux of the program is that you need to have some way of iterating over each integer in the SIN.

Since the easiest way is to convert the integer to a string for manipulation operations and back to an integer for addition/multiplication operations, I used the following approach:

The Program:

public class Program
{
    static void Main(string[] args)
    {
        int sn = 123456782;
        int[] Digits;
        int AddedResult = 0;
        string s = sn.ToString();
        string sa = s.Substring(s.Length - 1, 1);

        int checkDigit = Convert.ToInt32(sn.ToString().Substring(s.Length - 1, 1));
        //get the last digit.

        if (IsValidLength(sn))
        {

            sn = RemoveLastDigit(sn);
            Digits = ExtractEvenDigits(sn);
            Digits = DoubleDigits(Digits);
            AddedResult = AddedEvenDigits(Digits);
            AddedResult += AddOddDigits(sn);
            if (IsValidSN(AddedResult, checkDigit))
            {
                Console.WriteLine("The number is valid");
            }
            else
            {
                Console.WriteLine("The Number is not valid");
            }
        }
        else
        {
            Console.WriteLine("NotValidLength");
        }
        Console.Read();
        
    }

    public static bool IsValidSN(int AddedResult, int checkDigit)
    {
        return ((AddedResult % 10 == 0 && checkDigit == 0) || IsValidDifference(AddedResult, checkDigit));
        
    }

    public static bool IsValidDifference(int AddedResult, int checkDigit)
    {
        int nextHighestTens = AddedResult;
        while (nextHighestTens % 10 != 0)
        {
            nextHighestTens++;
        }
        return ((nextHighestTens - AddedResult) == checkDigit);
    }

    public static int AddOddDigits(int sn)
    {
        string s = sn.ToString();
        int i = 1;
        int addedResult = 0;
        foreach (char c in s)
        {
            if (i % 2 != 0)
            {
                addedResult += Convert.ToInt32(c.ToString());
            }
            i++;
        }

        return addedResult;
    }

    public static int AddedEvenDigits(int[] Digits)
    {
        int addedEvenDigits = 0;
        string s = "";
        for (int i = 0; i < Digits.Length; i++) //extract each digit. For example 12 is extracted as 1 and 2
        {
            s += Digits[i].ToString();
        }
        for (int i = 0; i < s.Length; i++) //now add all extracted digits
        {
            addedEvenDigits += Convert.ToInt32(s[i].ToString());
        }
        return addedEvenDigits;
    }

    public static int[] DoubleDigits(int[] Digits)
    {
        int[] doubledDigits = new int[Digits.Count()];
        for (int i = 0; i < Digits.Length; i++)
        {
            doubledDigits[i] = Digits[i] * 2;
        }
        return doubledDigits;
    }

    public static int[] ExtractEvenDigits(int sn)
    {
        int[] EvenDigits = new int[4];
        string s = sn.ToString(); //12345678

        int j = 0;
        for (int i = 1; i < s.Length; i += 2)
        {
            EvenDigits[j] = Convert.ToInt32(s[i].ToString());
            j++;
        }
        
        return EvenDigits;
    }

    public static int RemoveLastDigit(int sn)
    {
        string s = sn.ToString();
        return Convert.ToInt32(s.Substring(0, s.Count() - 1));
    }
    public static bool IsValidLength(int sn)
    {
        return (sn > 9999999 && sn < 1000000000);
    }
}

I wrote this in about 20 minutes, so it's not really worthy to turn in. I plan on improving it as an exercise, and I wrote some unit tests for it (that I plan on making better).

[TestFixture]
public class SINTests
{
    private int SinNumber = 123456782;

    [Test]
    public void TestValidNumber()
    {
        Assert.IsTrue(Program.IsValidLength(SinNumber));
    }
    
    [Test]
    public void TestRemoveLastDigit()
    {
        Assert.AreEqual(12345678, Program.RemoveLastDigit(SinNumber));
    }

    [Test]
    public void TestExtractEvenDigit()
    {
        int sn = 12345678;
        int[] array = new int[] { 2,4,6,8 };
        Assert.AreEqual(array, Program.ExtractEvenDigits(sn));
    }

    [Test]
    public void TestAddOddDigits()
    {
        int sn = 12345678;
        int result = 1 + 3 + 5 + 7;
        Assert.AreEqual(result, Program.AddOddDigits(sn));
    }
    [Test]
    public void TestDoubleEvenDigits()
    {
        int sn = 12345678;
        int[] original = new int[] { 2, 4, 6, 8 };
        int[] array = new int[] { 4, 8, 12, 16 };
        Assert.AreEqual(array, Program.DoubleDigits(original));
    }
    [Test]
    public void TestOddDigits()
    {
        int sn = 12345678;
        Assert.AreEqual(16, Program.AddOddDigits(sn));
    }

}

Since a string can be construed as an Array of Characters¹, the operations that work on a string also need to be aware of the fact that Converting a character to an integer is different than converting a string to an integer. For instance:

Char c = '2';
int cInt = Convert.ToInt32(c); // returns 50
string s = c.ToString();
int sInt = Convert.ToInt32(s) //returns 2;

¹Technically, a string is not an array of Characters in C# (though it is in C and C++), but because you can access the components of a string through an indexer, it can be treated like an array of characters.