Q4 07 Build order.

Ch 01. Arrays and Strings/Ch 01. Arrays and Strings.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp1.1</TargetFramework>
+    <TargetFramework>netstandard2.0</TargetFramework>
     <RootNamespace>Chapter01</RootNamespace>
   </PropertyGroup>
 

Ch 01. Arrays and Strings/Q1_05_One_Away_A.cs → Ch 01. Arrays and Strings/Q1 05 One Edit Away.cs

@@ -1,113 +1,117 @@
-using ctci.Contracts;
-using System;
-
-namespace Chapter01
-{
-    public class Q1_05_One_Away_A : Question
-    {
-        public static bool OneEditReplace(String s1, String s2)
-        {
-            bool foundDifference = false;
-            for (int i = 0; i < s1.Length; i++)
-            {
-                if (s1[i] != s2[i])
-                {
-                    if (foundDifference)
-                    {
-                        return false;
-                    }
-
-                    foundDifference = true;
-                }
-            }
-            return true;
-        }
-
-        /* Check if you can insert a character into s1 to make s2. */
-
-        public static bool OneEditInsert(String s1, String s2)
-        {
-            int index1 = 0;
-            int index2 = 0;
-            while (index2 < s2.Length && index1 < s1.Length)
-            {
-                if (s1[index1] != s2[index2])
-                {
-                    if (index1 != index2)
-                    {
-                        return false;
-                    }
-                    index2++;
-                }
-                else {
-                    index1++;
-                    index2++;
-                }
-            }
-            return true;
-        }
-
-        public static bool OneEditAway(String first, String second)
-        {
-            if (first.Length == second.Length)
-            {
-                return OneEditReplace(first, second);
-            }
-            else if (first.Length + 1 == second.Length)
-            {
-                return OneEditInsert(first, second);
-            }
-            else if (first.Length - 1 == second.Length)
-            {
-                return OneEditInsert(second, first);
-            }
-            return false;
-        }
-
-        public static bool OneEditAway2(String first, String second)
-        {
-            /* Length checks. */
-            if (Math.Abs(first.Length - second.Length) > 1)
-            {
-                return false;
-            }
-
-            /* Get shorter and longer string.*/
-            String s1 = first.Length < second.Length ? first : second;
-            String s2 = first.Length < second.Length ? second : first;
-
-            int index1 = 0;
-            int index2 = 0;
-            bool foundDifference = false;
-            while (index2 < s2.Length && index1 < s1.Length)
-            {
-                if (s1[index1] != s2[index2])
-                {
-                    /* Ensure that this is the first difference found.*/
-                    if (foundDifference) return false;
-                    foundDifference = true;
-                    if (s1.Length == s2.Length)
-                    { // On replace, move shorter pointer
-                        index1++;
-                    }
-                }
-                else {
-                    index1++; // If matching, move shorter pointer
-                }
-                index2++; // Always move pointer for longer string
-            }
-            return true;
-        }
-
-        public override void Run()
-        {
-            String a = "pse";
-            String b = "pale";
-            bool isOneEdit = OneEditAway(a, b);
-            Console.WriteLine("{0}, {1}: {2}", a, b, isOneEdit);
-
-            bool isOneEdit2 = OneEditAway2(a, b);
-            Console.WriteLine("{0}, {1}: {2}", a, b, isOneEdit2);
-        }
-    }
+using ctci.Contracts;
+using System;
+
+namespace Chapter01
+{
+    public class Q1_05_One_Edit_Away : Question
+    {
+        public override void Run()
+        {
+            String a = "pse";
+            String b = "pale";
+            var c = "ple";
+            var d = "pele";
+            Console.WriteLine($"{a}, {b}: {OneEditAway(a, b)} / {OneEditAwayBook(a, b)}");
+            Console.WriteLine($"{b}, {c}: {OneEditAway(b, c)} / {OneEditAwayBook(b, c)}");
+            Console.WriteLine($"{b}, {d}: {OneEditAway(b, d)} / {OneEditAwayBook(b, d)}");
+
+
+        }
+        public static bool OneEditReplace(String s1, String s2)
+        {
+            bool foundDifference = false;
+            for (int i = 0; i < s1.Length; i++)
+            {
+                if (s1[i] != s2[i])
+                {
+                    if (foundDifference)
+                    {
+                        return false;
+                    }
+
+                    foundDifference = true;
+                }
+            }
+            return true;
+        }
+
+        /* Check if you can insert a character into s1 to make s2. */
+
+        public static bool OneEditInsert(String s1, String s2)
+        {
+            int index1 = 0;
+            int index2 = 0;
+            while (index2 < s2.Length && index1 < s1.Length)
+            {
+                if (s1[index1] != s2[index2])
+                {
+                    if (index1 != index2)
+                    {
+                        return false;
+                    }
+                    index2++;
+                }
+                else
+                {
+                    index1++;
+                    index2++;
+                }
+            }
+            return true;
+        }
+
+        public static bool OneEditAway(String first, String second)
+        {
+            if (first.Length == second.Length)
+            {
+                return OneEditReplace(first, second);
+            }
+            else if (first.Length + 1 == second.Length)
+            {
+                return OneEditInsert(first, second);
+            }
+            else if (first.Length - 1 == second.Length)
+            {
+                return OneEditInsert(second, first);
+            }
+            return false;
+        }
+
+        public static bool OneEditAwayBook(String first, String second)
+        {
+            /* Length checks. */
+            if (Math.Abs(first.Length - second.Length) > 1)
+            {
+                return false;
+            }
+
+            /* Get shorter and longer string.*/
+            String shorter = first.Length < second.Length ? first : second;
+            String longer = first.Length < second.Length ? second : first;
+
+            int indexS = 0;
+            int indexL = 0;
+            bool foundDifference = false;
+            while (indexL < longer.Length && indexS < shorter.Length)
+            {
+                if (shorter[indexS] != longer[indexL])
+                {
+                    /* Ensure that this is the first difference found.*/
+                    if (foundDifference) return false;
+                    foundDifference = true;
+                    if (shorter.Length == longer.Length)
+                    { // On replace, move shorter pointer
+                        indexS++;
+                    }
+                }
+                else
+                {
+                    indexS++; // If matching, move shorter pointer
+                }
+                indexL++; // Always move pointer for longer string
+            }
+            return true;
+        }
+
+    }
 }

Ch 01. Arrays and Strings/Q1_01_Is_Unique.cs

@@ -1,50 +1,42 @@
 using ctci.Contracts;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Chapter01
 {
     public class Q1_01_Is_Unique : Question
     {
-        private bool IsUniqueChars(string str)
+        public bool IsUniqueChars(string str)
         {
             if (str.Length > 256)
-            {
-                return false;
-            }
+                throw new ArgumentException("String has to be less than 256 characters");
 
             var checker = 0;
             for (var i = 0; i < str.Length; i++)
             {
                 var val = str[i] - 'a';
-
-                if ((checker & (1 << val)) > 0)
-                {
-                    return false;
-                }
+                if ((checker & (1 << val)) > 0) return false;
                 checker |= (1 << val);
             }
 
             return true;
         }
 
-        private bool IsUniqueChars2(String str)
+        public bool IsUniqueChars2(String str)
         {
             var hashset = new HashSet<char>();
-            foreach(var c in str)
+            foreach (var c in str)
             {
                 if (hashset.Contains(c)) return false;
                 hashset.Add(c);
             }
-
             return true;
         }
 
         public override void Run()
         {
-            string[] words = { "abcde", "hello", "apple", "kite", "padle" };
-
-            foreach (var word in words)
+            foreach (var word in new string[] { "abcde", "hello", "apple", "kite", "padle" })
             {
                 Console.WriteLine(word + ": " + IsUniqueChars(word) + " " + IsUniqueChars2(word));
             }

Ch 01. Arrays and Strings/Q1_02_Check_Permutation.cs

@@ -1,6 +1,7 @@
 using ctci.Contracts;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Chapter01
 {
@@ -9,27 +10,21 @@ public class Q1_02_Check_Permutation : Question
         private bool IsPermutation(string original, string valueToTest)
         {
             if (original.Length != valueToTest.Length)
-            {
                 return false;
-            }
 
             var originalAsArray = original.ToCharArray();
             Array.Sort(originalAsArray);
-            original = new string(originalAsArray);
 
             var valueToTestAsArray = valueToTest.ToCharArray();
             Array.Sort(valueToTestAsArray);
-            valueToTest = new string(valueToTestAsArray);
 
-            return original.Equals(valueToTest);
+            return originalAsArray.SequenceEqual(valueToTestAsArray);
         }
 
         private bool IsPermutation2(string original, string valueToTest)
         {
             if (original.Length != valueToTest.Length)
-            {
                 return false;
-            }
 
             var letterCount = new Dictionary<char, int>();
 

Ch 01. Arrays and Strings/Q1_07_Rotate_Matrix.cs

@@ -6,42 +6,44 @@ namespace Chapter01
 {
     public class Q1_07_Rotate_Matrix : Question
     {
-        private void Rotate(int[][] matrix, int n)
+        private void Rotate(int[,] matrix, int n)
         {
             for (var layer = 0; layer < n / 2; ++layer)
             {
                 var first = layer;
                 var last = n - 1 - layer;
-
                 for (var i = first; i < last; ++i)
                 {
                     var offset = i - first;
-                    var top = matrix[first][i]; // save top
+                    var top = matrix[first, i]; // save top, left
 
-                    // left -> top
-                    matrix[first][i] = matrix[last - offset][first];
+                    // top, left <- bottom, left 
+                    matrix[first, i] = matrix[last - offset, first];
 
-                    // bottom -> left
-                    matrix[last - offset][first] = matrix[last][last - offset];
+                    // bottom, left <- bottom, right
+                    matrix[last - offset, first] = matrix[last, last - offset];
 
-                    // right -> bottom
-                    matrix[last][last - offset] = matrix[i][last];
+                    // bottom, right <- top, right
+                    matrix[last, last - offset] = matrix[i, last];
 
-                    // top -> right
-                    matrix[i][last] = top; // right <- saved top
+                    // top, right <- top
+                    matrix[i, last] = top;
                 }
             }
         }
 
         public override void Run()
         {
-            const int size = 3;
-
-            var matrix = AssortedMethods.RandomMatrix(size, size, 0, 9);
+            var matrix = new[,]
+            {
+                {1,2,3 },
+                {4,5,6 },
+                {7,8,9 }
+            };
 
             AssortedMethods.PrintMatrix(matrix);
 
-            Rotate(matrix, size);
+            Rotate(matrix, matrix.GetLength(0));
             Console.WriteLine();
             AssortedMethods.PrintMatrix(matrix);
         }