Assn5 - Prob1

Added test case

Incorporated PrependPair helper method

Author: brillan150

Assignment5/Problem1.cs

@@ -38,6 +38,11 @@ public static void RunTests()
                     InputIntArray = new int[]{ 4 },
                     CorrectNGEString = "{ {4, -1} }",
                 },
+                new TestCase
+                {
+                    InputIntArray = new int[]{ 12, 8, 2, 20, 10, 5, 3, -4 },
+                    CorrectNGEString = "{ {12, 20}, {8, 20}, {2, 20}, {20, -1}, {10, -1}, {5, -1}, {3, -1}, {-4, -1} }",
+                },
                 //new TestCase
                 //{
                 //    InputIntArray = new int[]{ 12, 9, 20, 10, 8, 0, 6, 9, 5, 10, 11},
@@ -148,36 +153,49 @@ public static string PrintElementsWithNextGreaterElements(int[] arr)
 			if (arr.Length == 0)
 				return "{}";
 
-			if (arr.Length == 1)
-				return $"{{ {{{arr[0]}, {DEFAULT_NGE}}} }}";
-			// For an interpolated string, use "{{" for a single '{' and "}}" for a single '}'
+            var builder = new StringBuilder(" }");
+            // Using the helper here instead of writing out the pattern multiple times
+            // to be consistent
+            PrependPair(arr[^1], DEFAULT_NGE, builder);
+            // The last element, which may also be the first, and if it is:
 
-			// Remember that the Array.Clone method returns an object[], must cast it to appropriate type
-			var arrNGE = (int[])arr.Clone();
+            // Main logic requires array length of at least two
+            if (arr.Length == 1)
+            {
+                builder[0] = '{';
+                return builder.ToString();
+            }
+            //// From back when we were using a paralell array to store NGEs
+            //// Remember that the Array.Clone method returns an object[], must cast it to appropriate type
+            //var arrNGE = (int[])arr.Clone();
+            //// By definition
+            //arrNGE[^1] = DEFAULT_NGE;
 
-			var localMaxes = new Stack<int>();
-			// remains empty until the right element of a pair is actually larger than the left element of a pair
 
-			// By definition
-			arrNGE[^1] = DEFAULT_NGE;
+            var localMaxes = new Stack<int>();
+            // remains empty until the right element of a pair is actually larger than the left element of a pair
 
-			// Will refer to result of last comparison to determine if arr[i + 1] is determined to be a new local maximum
-			var lastResult = CompResult.NoNotLessThan;
+            // Will refer to result of last comparison to determine if arr[i + 1] is determined to be a new local maximum
+            var lastResult = CompResult.NoNotLessThan;
 			// NoNotLessThan is correct for the "comparison" between arr[^1] and the non-element to its right, since arr[^1] will be a local max if arr[i] < arr[i + 1]
 			// Default is reserved to essentially mean uninitialized
 
 			var thisResult = CompResult.Default;
 
-			// walk array from right to left
-			// i starts at next-to-last index
-			// compare the elements in pairs
-			for (var i = arr.Length - 2; i >= 0; --i)
+
+            // walk array from right to left
+            // i starts at next-to-last index
+            // compare the elements in pairs
+            for (var i = arr.Length - 2; i >= 0; --i)
 			{
 				if (arr[i] < arr[i + 1])
 				// Immediately adjacent element is NGE
 				{
 					thisResult = CompResult.YesLessThan;
-					arrNGE[i] = arr[i + 1];
+                    PrependPair(arr[i], arr[i + 1], builder);
+
+                    // From back when we were using a paralell array to store NGEs
+					//arrNGE[i] = arr[i + 1];
 
 					if (lastResult == CompResult.NoNotLessThan)
 					{
@@ -195,7 +213,11 @@ public static string PrintElementsWithNextGreaterElements(int[] arr)
                     {
                         if (arr[i] < localMaxes.Peek())
                         {
-                            arrNGE[i] = localMaxes.Peek();
+                            PrependPair(arr[i], localMaxes.Peek(), builder);
+
+                            // From back when we were using a paralell array to store NGEs
+                            //arrNGE[i] = localMaxes.Peek();
+                            
                             // Leave the NGE that we just used where we found it in localMaxes, it is still a candidate to be an NGE again in the future
                             foundNGE = true;
                         }
@@ -209,46 +231,52 @@ public static string PrintElementsWithNextGreaterElements(int[] arr)
 					if (localMaxes.Count == 0)
 					// No candidate NGEs exist, or arr[i] was greater than each candidate NGE
 					{
-						arrNGE[i] = DEFAULT_NGE;
-					}
+                        PrependPair(arr[i], DEFAULT_NGE, builder);
 
-					// Not pushing onto localMaxes here, since we won't know until next iteration whether the current arr[i] is a local max
-				}
+                        // From back when we were using a paralell array to store NGEs
+                        //arrNGE[i] = DEFAULT_NGE;
+                    }
+
+                    // Not pushing onto localMaxes here, since we won't know until next iteration whether the current arr[i] is a local max
+                }
 
 				// Advance state of tracking for next loop iteration
 				lastResult = thisResult;
 				thisResult = CompResult.Default;
 			}
 
-			// Now construct the string left to right (or print it out as you go...but not since we're doing fixup at the end of the string building...and we're headed back to build the string as we go in the next version anyway)
+            // Now construct the string left to right (or print it out as you go...but not since we're doing fixup at the end of the string building...and we're headed back to build the string as we go in the next version anyway)
 
-			// Example: { {4, 5}, {5, 25}, {2, 25}, {25, -1} }
+            // Example: { {4, 5}, {5, 25}, {2, 25}, {25, -1} }
 
             // TODO: Tell the builder how big it needs to be to avoid later reallocation
             // (Since we already know)
-			var builder = new StringBuilder("{ ");
 
 
-            // BUG: it's either k < arr.Length OR k <= arr.Length-1
-			for (var k = 0; k < arr.Length; ++k)
-			{
-				// It's Append, not Add, for StringBuilder, right?
-				builder.Append($"{{{arr[k]}, {arrNGE[k]}}}, ");
-                // BUG: array index var for this loop is k, not i
-                // But this loop is going away in the next version anyway
-			}
+            // From back when we were using a paralell array to store NGEs
+            //         // BUG: it's either k < arr.Length OR k <= arr.Length-1
+            //for (var k = 0; k < arr.Length; ++k)
+            //{
+            //	// It's Append, not Add, for StringBuilder, right?
+            //	builder.Append($"{{{arr[k]}, {arrNGE[k]}}}, ");
+            //             // BUG: array index var for this loop is k, not i
+            //             // But this loop is going away in the next version anyway
+            //}
+
+            //         // Drop the last comma
+            //         // param1: remove starting from what index
+            //         // param2: how many to remove
+            //         // that is: builder.Remove(where, howmany);
+            //         builder.Remove(builder.Length - 2, 1);
 
-            // Drop the last comma
-            // param1: remove starting from what index
-            // param2: how many to remove
-            // that is: builder.Remove(where, howmany);
-            builder.Remove(builder.Length - 2, 1);
+            //// Add the final curly brace
+            //builder.Append('}');
 
-			// Add the final curly brace
-			builder.Append('}');
 
+            // Overwrite the final leading comma inserted by PrependPair
+            builder[0] = '{';
 
-			return builder.ToString();
+            return builder.ToString();
 
 
 			// Go ahead and finish writing this, test that this solution works, then tomorrow adapt it to build the string right to left during initial traversal of the array (instead of cloning the array)
@@ -261,19 +289,26 @@ public static string PrintElementsWithNextGreaterElements(int[] arr)
 		}
 
 
-        private void PrependPair(int ele, int nge, StringBuilder sb)
+        // Thought about telling StringBuilder how big to be,
+        // but that depends on how many digits each key and value
+        // ends up being.
+        // Let's leave out this complexity for now.
+
+        private static void PrependPair(int ele, int nge, StringBuilder sb)
         {
             // Example of overall finished string:
             // "{ {4, 5}, {5, 25}, {2, 25}, {25, -1} }"
 
             // Each call adds this much:
-            // ", {25, -1} "
+            // ", {25, -1}"
 
             // param1: insert starting at what index
             // param2: what to insert
             // that is: sb.Insert(where, what);
 
-            sb.Insert(0, $", {{{ele}, {nge}}} ");
+            // For an interpolated string, use "{{" for a single '{' and "}}" for a single '}'
+
+            sb.Insert(0, $", {{{ele}, {nge}}}");
 
 
             // Character array would be more performant