Merge pull request kontur-courses#4 from kontur-courses/OneMoreContro…

…lDigit

One more control digit

cs/ControlDigit/ControlDigit.csproj

@@ -44,16 +44,18 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ControlDigitExtensions.cs" />
+    <Compile Include="Isbn13\UpcExtensions.cs" />
+    <Compile Include="Snils\SnilsExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="ControlDigitExtensions_Test.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="README.txt" />
+    <Compile Include="Snils\SnilsExtensions_Tests.cs" />
+    <Compile Include="Upc\UpcExtensions.cs" />
+    <Compile Include="Upc\UpcExtensions_Tests.cs" />
+    <Compile Include="Upc\Upc_PerformanceTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

cs/ControlDigit/Isbn13/UpcExtensions.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace ControlDigit
+{
+	public static class Isbn13Extensions
+	{
+		public static int CalculateIsbn13(this long number)
+		{
+			int sum = 0;
+			int factor = 1;
+			do
+			{
+				int digit = (int)(number % 10);
+				sum += factor * digit;
+				factor = 4 - factor;
+				number /= 10;
+			}
+			while (number > 0);
+			int m = sum % 10;
+			if (m == 0)
+				return 0;
+			return 10 - m;
+		}
+	}
+}

cs/ControlDigit/Snils/SnilsExtensions.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Linq;
+
+namespace ControlDigit
+{
+	public static class SnilsExtensions
+	{
+		public static int CalculateSnils(this long number)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}

cs/ControlDigit/Snils/SnilsExtensions_Tests.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Diagnostics;
+using NUnit.Framework;
+
+namespace ControlDigit
+{
+    [TestFixture]
+    public class SnilsExtensions_Tests
+    {
+        [TestCase(1, ExpectedResult = 1)]
+        [TestCase(10, ExpectedResult = 2)]
+        [TestCase(100, ExpectedResult = 3)]
+        [TestCase(1001, ExpectedResult = 4 + 1)]
+        [TestCase(1111, ExpectedResult = 4 + 3 + 2 + 1)]
+        [TestCase(112233445, ExpectedResult = 95)]
+        [TestCase(87654303, ExpectedResult = 0)]
+        [TestCase(87654302, ExpectedResult = 0)]
+        [TestCase(116973385, ExpectedResult = 89)]
+        [TestCase(152675138, ExpectedResult = 70)]
+        [TestCase(463436384, ExpectedResult = 96)]
+        [TestCase(158757369, ExpectedResult = 28)]
+        [TestCase(192168000, ExpectedResult = 62)]
+        public int Snils(long x)
+        {
+            return x.CalculateSnils();
+        }
+    }
+}

cs/ControlDigit/Solved/ControlDigitExtensions.cs

@@ -8,10 +8,18 @@ namespace ControlDigit.Solved
 {
 	public static class ControlDigitExtensions
 	{
-		public static int ControlDigit(this long number)
+		public static int CalculateSnils(this long number)
+		{
+			var sum = number
+						  .GetDigitsFromLeastSignificant()
+						  .SumWithWeights(Enumerable.Range(1, 9)) % 101;
+			return sum == 100 ? 0 : sum;
+		}
+
+		public static int CalculateUpcOld(this long number)
 		{
 			int sum = 0;
-			int factor = 1;
+			int factor = 3;
 			do
 			{
 				int digit = (int)(number % 10);
@@ -22,46 +30,46 @@ public static int ControlDigit(this long number)
 			}
 			while (number > 0);
 
-			int result = sum % 11;
-			if (result == 10)
-				result = 1;
-			return result;
+			int m = sum % 10;
+			if (m == 0)
+				return 0;
+			return 10 - m;
 		}
 
-        private static readonly int[] weights = new[] { 1, 3 }.Repeat().Take(20).ToArray();
+		private static readonly int[] weights = new[] { 3, 1 }.Repeat().Take(11).ToArray();
 
-        public static int ControlDigit2(this long number)
-        {
-            var sum = number
-                .GetDigitsFromLeastSignificant()
-                .SumWithWeights(weights) % 11;
-            return sum == 10 ? 1 : sum;
-        }
-    }
+		public static int CalculateUpc(this long number)
+		{
+			var m = number
+				.GetDigitsFromLeastSignificant()
+				.SumWithWeights(weights) % 10;
+			return m == 0 ? 0 : 10 - m;
+		}
+	}
 
-    // Общий код, ничего не знает про контрольные разряды и прикладную задачу.
-    public static class MoreEnumerableExtensions
-    {
-        public static IEnumerable<int> GetDigitsFromLeastSignificant(this long number)
-        {
-            do
-            {
-                yield return (int)(number % 10);
-                number /= 10;
-            } while (number > 0);
-        }
+	// Общий код, ничего не знает про контрольные разряды и прикладную задачу.
+	public static class MoreEnumerableExtensions
+	{
+		public static IEnumerable<int> GetDigitsFromLeastSignificant(this long number)
+		{
+			do
+			{
+				yield return (int)(number % 10);
+				number /= 10;
+			} while (number > 0);
+		}
 
-        public static int SumWithWeights(this IEnumerable<int> numbers, IEnumerable<int> weights)
-        {
-            return numbers.Zip(weights, (n, w) => n * w).Sum();
-        }
+		public static int SumWithWeights(this IEnumerable<int> numbers, IEnumerable<int> weights)
+		{
+			return numbers.Zip(weights, (n, w) => n * w).Sum();
+		}
 
-        public static IEnumerable<T> Repeat<T>(this IEnumerable<T> items)
-        {
-            var i2 = items.ToList();
-            while (true)
-                foreach (var item in i2) yield return item;
-            // ReSharper disable once FunctionNeverReturns
-        }
-    }
+		public static IEnumerable<T> Repeat<T>(this IEnumerable<T> items)
+		{
+			var i2 = items.ToList();
+			while (true)
+				foreach (var item in i2) yield return item;
+			// ReSharper disable once FunctionNeverReturns
+		}
+	}
 }

cs/ControlDigit/Solved/ControlDigitExtensions_Test.cs

@@ -9,43 +9,69 @@ namespace ControlDigit.Solved
     [TestFixture]
     public class ControlDigitExtensions_Tests
     {
-        [TestCase(0, ExpectedResult = 0)]
+        [TestCase(00000000000, ExpectedResult = 0)]
+        [TestCase(00000000001, ExpectedResult = 7)]
+        [TestCase(00000000002, ExpectedResult = 4)]
+        [TestCase(00000000009, ExpectedResult = 3)]
+        [TestCase(00000000010, ExpectedResult = 9)]
+        [TestCase(00000000013, ExpectedResult = 0)]
+        [TestCase(00000000015, ExpectedResult = 4)]
+        [TestCase(00000000017, ExpectedResult = 8)]
+        [TestCase(00000000018, ExpectedResult = 5)]
+        [TestCase(11111111111, ExpectedResult = 7)]
+        [TestCase(12345678901, ExpectedResult = 2)]
+        [TestCase(98765432101, ExpectedResult = 2)]
+        [TestCase(11223344556, ExpectedResult = 2)]
+        [TestCase(32512312431, ExpectedResult = 1)]
+        [TestCase(98439874398, ExpectedResult = 8)]
+        [TestCase(98439876398, ExpectedResult = 6)]
+        public int Upc(long x)
+        {
+            return x.CalculateUpc();
+        }
+
         [TestCase(1, ExpectedResult = 1)]
-        [TestCase(2, ExpectedResult = 2)]
-        [TestCase(9, ExpectedResult = 9)]
-        [TestCase(10, ExpectedResult = 3)]
-        [TestCase(15, ExpectedResult = 8)]
-        [TestCase(17, ExpectedResult = 1)]
-        [TestCase(18, ExpectedResult = 0)]
-        public int TestControlDigit(long x)
+        [TestCase(10, ExpectedResult = 2)]
+        [TestCase(100, ExpectedResult = 3)]
+        [TestCase(1001, ExpectedResult = 4 + 1)]
+        [TestCase(1111, ExpectedResult = 4 + 3 + 2 + 1)]
+        [TestCase(112233445, ExpectedResult = 95)]
+        [TestCase(87654303, ExpectedResult = 0)]
+        [TestCase(87654302, ExpectedResult = 0)]
+        [TestCase(116973385, ExpectedResult = 89)]
+        [TestCase(152675138, ExpectedResult = 70)]
+        [TestCase(463436384, ExpectedResult = 96)]
+        [TestCase(158757369, ExpectedResult = 28)]
+        [TestCase(192168000, ExpectedResult = 62)]
+        public int Snils(long x)
         {
-            return x.ControlDigit();
+            return x.CalculateSnils();
         }
 
+
         [Test]
-        public void CompareImplementations()
+        public void CompareUpcImplementations()
         {
             for (long i = 0; i < 100000; i++)
-                Assert.AreEqual(i.ControlDigit(), i.ControlDigit2());
+                Assert.AreEqual(i.CalculateUpcOld(), i.CalculateUpc(), i.ToString());
         }
     }
 
     [TestFixture]
-    public class ControlDigit_PerformanceTests
+    public class Upc_PerformanceTests
     {
         [Test]
-        public void TestControlDigitSpeed()
+        public void UpcPerformance()
         {
             var count = 10000000;
             var sw = Stopwatch.StartNew();
             for (int i = 0; i < count; i++)
-                12345678L.ControlDigit();
+                12345678L.CalculateUpcOld();
             Console.WriteLine("Old " + sw.Elapsed);
             sw.Restart();
             for (int i = 0; i < count; i++)
-                12345678L.ControlDigit2();
+                12345678L.CalculateUpc();
             Console.WriteLine("New " + sw.Elapsed);
         }
     }
-
-}
+}

cs/ControlDigit/Upc/UpcExtensions.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace ControlDigit
+{
+	public static class UpcExtensions
+	{
+		public static int CalculateUpc(this long number)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}