Added runs for the leetcode two-sum problem.

Hussy.Net.sln.DotSettings

@@ -1,2 +1,3 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=leetcode/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=tacosontitan/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

samples/Hussy.Net.Playground/Hussy.Net.Playground.csproj.DotSettings

@@ -2,4 +2,6 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=c270154/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=c270154_005Ctests/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=golfing_005Cc270154_005Ctests/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=golfing_005Cc270154/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=golfing_005Cc270154/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=leetcode_005Ceasy_005Ctwosum/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=leetcode_005Ceasy_005Ctwosum_005Ctests/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

samples/Hussy.Net.Playground/Leetcode/Easy/TwoSum/ComplexityRun.cs

@@ -0,0 +1,39 @@
+using Glitter.Collections;
+
+namespace Hussy.Net.Playground.Leetcode.Easy;
+
+/// <summary>
+/// Represents a solution and its tests for the leetcode two-sum problem.
+/// </summary>
+/// <see href="https://leetcode.com/problems/two-sum/description/"/>
+public sealed partial class TwoSum
+{
+    /// <summary>
+    ///     A direct approach to solving the problem with less time complexity
+    ///     to understand where Hussy may be lacking.
+    /// </summary>
+    /// <param name="numbers">The array of numbers to look through.</param>
+    /// <param name="target">
+    ///     The target number which the two numbers in <paramref name="numbers"/> must add up to.
+    /// </param>
+    /// <returns>
+    ///     The two indices of the numbers which add up to the <paramref name="target"/>.
+    /// </returns>
+    private static IEnumerable<int> ComplexityRun(
+        int[] numbers,
+        int target)
+    {
+        var seen = new Dictionary<int, int>();
+        for (var i = 0; i < numbers.Length; i++)
+        {
+            var currentNumber = numbers[i];
+            var complement = target - currentNumber;
+            if (seen.TryGetValue(complement, out var value))
+                return [value, i];
+
+            seen[currentNumber] = i;
+        }
+
+        return Enumerable.Empty<int>();
+    }
+}

samples/Hussy.Net.Playground/Leetcode/Easy/TwoSum/DryRun.cs

@@ -0,0 +1,39 @@
+namespace Hussy.Net.Playground.Leetcode.Easy;
+
+/// <summary>
+/// Represents a solution and its tests for the leetcode two-sum problem.
+/// </summary>
+/// <see href="https://leetcode.com/problems/two-sum/description/"/>
+public sealed partial class TwoSum
+{
+    /// <summary>
+    /// A very mundane and direct approach to solving the problem to understand where Hussy may be lacking.
+    /// </summary>
+    /// <param name="numbers">The array of numbers to look through.</param>
+    /// <param name="target">
+    ///     The target number which the two numbers in <paramref name="numbers"/> must add up to.
+    /// </param>
+    /// <returns>
+    ///     The two indices of the numbers which add up to the <paramref name="target"/>.
+    /// </returns>
+    private static IEnumerable<int> DryRun(
+        int[] numbers,
+        int target)
+    {
+        for (var x = 0; x < numbers.Length; x++)
+        {
+            for (var y = 0; y < numbers.Length; y++)
+            {
+                if (x == y)
+                    continue;
+
+                var a = numbers[x];
+                var b = numbers[y];
+                if (a + b == target)
+                    return [x, y];
+            }
+        }
+
+        return Enumerable.Empty<int>();
+    }
+}

samples/Hussy.Net.Playground/Leetcode/Easy/TwoSum/GolfRun.cs

@@ -0,0 +1,25 @@
+namespace Hussy.Net.Playground.Leetcode.Easy;
+
+/// <summary>
+/// Represents a solution and its tests for the leetcode two-sum problem.
+/// </summary>
+/// <see href="https://leetcode.com/problems/two-sum/description/"/>
+public sealed partial class TwoSum
+{
+    /// <summary>
+    ///     A simple golf run to prepare for the Hussy run.
+    /// </summary>
+    /// <param name="numbers">The array of numbers to look through.</param>
+    /// <param name="target">
+    ///     The target number which the two numbers in <paramref name="numbers"/> must add up to.
+    /// </param>
+    /// <returns>
+    ///     The two indices of the numbers which add up to the <paramref name="target"/>.
+    /// </returns>
+    private static IEnumerable<int> GolfRun(
+        int[] numbers,
+        int target)
+    {
+        return Enumerable.Empty<int>();
+    }
+}

samples/Hussy.Net.Playground/Leetcode/Easy/TwoSum/Overview.cs

@@ -0,0 +1,58 @@
+namespace Hussy.Net.Playground.Leetcode.Easy;
+
+/// <summary>
+/// Represents a solution and its tests for the leetcode two-sum problem.
+/// </summary>
+/// <see href="https://leetcode.com/problems/two-sum/description/"/>
+public sealed partial class TwoSum
+{
+    /// <summary>
+    ///     Given an array of integers <paramref name="numbers"/> and an integer <paramref name="target"/>,
+    ///     return the indices of the two numbers within <paramref name="numbers"/> that add up to the
+    ///     specified <paramref name="target"/>.
+    /// </summary>
+    /// <param name="numbers">The array of numbers to look through.</param>
+    /// <param name="target">
+    ///     The target number which the two numbers in <paramref name="numbers"/> must add up to.
+    /// </param>
+    /// <returns>
+    ///     The indices of the two numbers within <paramref name="numbers"/> that add up to the
+    ///     specified <paramref name="target"/>.
+    /// </returns>
+    /// <remarks>
+    ///     <para>You can return the answer in <i>any</i> order.</para>
+    ///     <para>
+    ///         <b>Requirements:</b>
+    ///         <list type="bullet">
+    ///             <item>You may <b>NOT</b> use the same element twice.</item>
+    ///         </list>
+    ///     </para>
+    ///     <para>
+    ///         <b>Assumptions:</b>
+    ///         <list type="bullet">
+    ///             <item>
+    ///                 Each sequence of <paramref name="numbers"/> will have <i>exactly
+    ///                 <b>one</b></i> solution.
+    ///             </item>
+    ///         </list>
+    ///     </para>
+    ///     <para>
+    ///         <b>Constraints:</b>
+    ///         <list type="bullet">
+    ///             <item>
+    ///                 <c>2</c> is less than or equal to <paramref name="numbers"/><c>.Length</c> is less than or equal to <c>104</c>
+    ///             </item>
+    ///             <item>
+    ///                 <c>-109</c> is less than or equal to <c>nums[i]</c> is less than or equal to <c>109</c>
+    ///             </item>
+    ///             <item>
+    ///                 <c>-109</c> is less than or equal to <paramref name="target"/> is less than or equal to <c>109</c>
+    ///             </item>
+    ///             <item>Only one valid answer exists.</item>
+    ///         </list>
+    ///     </para>
+    /// </remarks>
+    private delegate IEnumerable<int> TestFunction(
+        int[] numbers,
+        int target);
+}

samples/Hussy.Net.Playground/Leetcode/Easy/TwoSum/Tests/Setup.cs

@@ -0,0 +1,38 @@
+namespace Hussy.Net.Playground.Leetcode.Easy;
+
+/// <summary>
+/// Represents a solution and its tests for the leetcode two-sum problem.
+/// </summary>
+/// <see href="https://leetcode.com/problems/two-sum/description/"/>
+public sealed partial class TwoSum
+{
+    /// <summary>
+    /// Gets the functions the tests should be applied to.
+    /// </summary>
+    private static TestFunction[] TestFunctions =>
+    [
+        DryRun,
+        ComplexityRun,
+        GolfRun
+    ];
+
+    /// <summary>
+    /// Tests all runs to ensure each has the same expected result.
+    /// </summary>
+    private static void RunTest(
+        IEnumerable<int> expectedResults,
+        int[] numbers,
+        int target)
+    {
+        var expectedSequence = expectedResults.ToList();
+        foreach (var testFunction in TestFunctions)
+        {
+            var results = testFunction(numbers, target);
+            var resultingSequence = results.ToList();
+
+            var excessResults = resultingSequence.Except(expectedSequence);
+            Assert.True(expectedSequence.TrueForAll(resultingSequence.Contains));
+            Assert.Empty(excessResults);
+        }
+    }
+}

samples/Hussy.Net.Playground/Leetcode/Easy/TwoSum/Tests/TestOne.cs

@@ -0,0 +1,20 @@
+namespace Hussy.Net.Playground.Leetcode.Easy;
+
+/// <summary>
+/// Represents a solution and its tests for the leetcode two-sum problem.
+/// </summary>
+/// <see href="https://leetcode.com/problems/two-sum/description/"/>
+public sealed partial class TwoSum
+{
+    /// <summary>
+    ///     The first example given on Leetcode comes with the explanation that
+    ///     the numbers <c>2</c> and <c>7</c> which are located at indices <c>0</c>
+    ///     and <c>1</c>, respectively, add up to the specified target value of
+    ///     <c>9</c> so the expected output is <c>[0, 1]</c>.
+    /// </summary>
+    [Fact]
+    public void TestCaseOne_Passes() => RunTest(
+        expectedResults: [0, 1],
+        numbers: [2, 7, 11, 15],
+        target: 9);
+}

samples/Hussy.Net.Playground/Leetcode/Easy/TwoSum/Tests/TestThree.cs

@@ -0,0 +1,14 @@
+namespace Hussy.Net.Playground.Leetcode.Easy;
+
+/// <summary>
+/// Represents a solution and its tests for the leetcode two-sum problem.
+/// </summary>
+/// <see href="https://leetcode.com/problems/two-sum/description/"/>
+public sealed partial class TwoSum
+{
+    [Fact]
+    public void TestCaseThree_Passes() => RunTest(
+        expectedResults: [0, 1],
+        numbers: [3, 3],
+        target: 6);
+}

samples/Hussy.Net.Playground/Leetcode/Easy/TwoSum/Tests/TestTwo.cs

@@ -0,0 +1,14 @@
+namespace Hussy.Net.Playground.Leetcode.Easy;
+
+/// <summary>
+/// Represents a solution and its tests for the leetcode two-sum problem.
+/// </summary>
+/// <see href="https://leetcode.com/problems/two-sum/description/"/>
+public sealed partial class TwoSum
+{
+    [Fact]
+    public void TestCaseTwo_Passes() => RunTest(
+        expectedResults: [1, 2],
+        numbers: [3, 2, 4],
+        target: 6);
+}