public void BinarySearchIterativeTest()
{
var array = new int[] { 20, 52, 98, 105, 128, 154, 178 };
var toFind = 20;
var result = MySolution.BinarySearch(array, toFind);
Assert.IsTrue(result, "The result differs from what is expected.");
}
public void TestKO()
{
//Arrange
var s = "{[([)]}";
//Act
var result = MySolution.CheckParenthesis(s);
//Assert
Assert.IsFalse(result, "Result differs from what is expected.");
}
/// <summary>
/// 添加一个项目文件
/// </summary>
/// <param name="pro">要添加的项目类</param>
public void AddProjectClass(ProjectClass pro)
{
if (!MySolution.Contains(pro))
{
MySolution.Add(pro);
MyProjectFiles file = new MyProjectFiles();
file.Name = pro.ProjectName;
file.Path = pro.FilesPath;
MyProjectClassFile.Add(file);
}
}
public void RecursiveSumOfDigitsNumberFor4321()
{
//Assign
var n = 4321;
var expected = 10;
//Act
var result = MySolution.RecursiveSumOfDigitsNumber(n);
Assert.AreEqual(result, expected, "Result differs from what is expected");
}
public void RecursiveSumOf4()
{
//Arrange
var n = 4;
var expected = 10;
//Act
var result = MySolution.RecursiveSum(n);
//Assert
Assert.AreEqual(expected, result, "Result differs from what is expected");
}
public void RecursiveSumWithFormula()
{
//Arrange
var n = 1000;
var expected = (n * (n + 1)) / 2;
//Act
var result = MySolution.RecursiveSum(n);
//Assert
Assert.AreEqual(expected, result, "Result differs from what is expected");
}
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
MySolution solution1 = new MySolution(N);
solution1.Run();
//SampleSolution solution2 = new SampleSolution(N);
//HashSet<string> result2 = solution2.Run();
//Console.WriteLine($"count1: {result1.Count} count2: {result2.Count}");
}
public void RecursiveReverseStringTest2()
{
//Assign
var input = "hello world";
var expected = "dlrow olleh";
//Act
var result = MySolution.RecursiveReverseString(input);
//Assert
Assert.AreEqual(result, expected, "The result differs from what is expected.");
}
public void ShortestBinaryArrayTest2()
{
//Arrange
var testArray = new int[] { 15, 3, 0, 5, 1 };
var expected = 5;
//Act
var result = MySolution.ShortestBinaryArray(testArray);
//Assert
Assert.AreEqual(result, expected, "Result differs from what is expected.");
}
public void Solution_ReturnsValue_WhenCalled(int[] a, int expected)
{
// Arrange
var sut = new MySolution();
// Act
var actual = sut.Solution(a);
// Assert
Assert.Equal(expected,
actual);
}
public void Solution_ReturnsValue_ForLargeArray()
{
// Arrange
var a = CreateLargeValidPermutationArray(1000000);
var sut = new MySolution();
// Act
var actual = sut.Solution(a);
// Assert
Assert.Equal(1, actual);
}
public void DynammicRecursiveFibonacciTest()
{
//Assign
var n = 10;
var expected = 55;
//Act
var result = MySolution.DynamicRecursiveFibonacci(n);
//Assert
Assert.AreEqual(result, expected, "Result differs from what is expected.");
}
public void IterativeFibonacciTest()
{
//Assign
var n = 23;
var expected = 28657;
//Act
var result = MySolution.IterativeFibonacci(n);
//Assert
Assert.AreEqual(result, expected, "Result differs from what is expected.");
}
public void SumOfMultiplesOf3And5ResultFor1000()
{
//Arrange
const int n = 1000;
const int expected = 233168;
//Act
var actual = MySolution.SumOfMultiplesOf3And5(n);
//Assert
Assert.AreEqual(expected, actual, "Result is not what is expected");
}
public void RecursiveReverseStringTest3()
{
//Assign
var input = "123456789";
var expected = "987654321";
//Act
var result = MySolution.RecursiveReverseString(input);
//Assert
Assert.AreEqual(result, expected, "The result differs from what is expected.");
}
public void FindIndexOfFirstUniqueEmptyNullTest()
{
//Assign
string input = null;
var expected = -1;
//Act
var result = MySolution.FindIndexOfFirstUnique(input);
//Assert
Assert.AreEqual(result, expected, "The result differs from what is expected.");
}
public void SumOfOthersTest1Element()
{
//Arrange
var input = new int[] { 2000000000 };
var expected = new int[] { 0 };
//Act
var result = MySolution.SumOfOthers(input);
//Assert
CollectionAssert.AreEqual(result, expected, "Result differs from what was expected.");
}
public void FindIndexOfFirstUniqueAbsentTest()
{
//Assign
var input = "aabbcceeddff";
var expected = -1;
//Act
var result = MySolution.FindIndexOfFirstUnique(input);
//Assert
Assert.AreEqual(result, expected, "The result differs from what is expected.");
}
public void FindIndexOfFirstUnique1CharTest()
{
//Assign
var input = "a";
var expected = 0;
//Act
var result = MySolution.FindIndexOfFirstUnique(input);
//Assert
Assert.AreEqual(result, expected, "The result differs from what is expected.");
}
public void SumOfOthersTestRegular()
{
//Arrange
var input = new int[] { 1, 2, 3, 4, 5, 6 };
var expected = new int[] { 20, 18, 15, 11, 6, 0 };
//Act
var result = MySolution.SumOfOthers(input);
//Assert
CollectionAssert.AreEqual(result, expected, "Result differs from what was expected.");
}
public void FunctionUnderTest_ExpectedResult_UnderCondition(
int[] a,
int x,
int expected)
{
// Arrange
var sut = new MySolution();
// Act
var actual = sut.Solution(x, a);
// Assert
Assert.Equal(expected, actual);
}
public void RecursiveCoinChangeV2Test()
{
//Arrange
var coins = new int[] { 1, 5, 10, 21, 25 };
var target = 63;
var expected = 3;
//Act
var result = MySolution.CoinChangeV2(target, coins, new Dictionary <int, int>());
//Assert
Assert.AreEqual(result, expected, "Result differs from what is expected.");
}
/// <summary>
/// 删除一个项目
/// </summary>
/// <param name="pro">要删除的项目</param>
public void DelProjectClass(ProjectClass pro)
{
if (MySolution.Contains(pro))
{
MySolution.Remove(pro);
foreach (MyProjectFiles file in MyProjectClassFile)
{
if (file.Name == pro.ProjectName)
{
MyProjectClassFile.Remove(file);
}
}
}
}
public void RecursivePermutationTest1()
{
//Assign
var input = "abc";
var expected = new List <string>()
{
"abc", "acb", "bac", "bca", "cab", "cba"
};
//Act
var result = MySolution.Perm(input);
//Assert
CollectionAssert.AreEqual(result, expected, "Result differs from what is expected.");
}
public void RecursiveWordSplitTest3()
{
//Assign
var phrase = "themanran";
var words = new List <string>()
{
"clown", "ran", "man"
};;
var expected = new List <string>();
//Act
var result = MySolution.WordSplitRecursive(phrase, words);
//Assert
CollectionAssert.AreEqual(result, expected, "Result differs from what is expected.");
}
private static IList <IList <int> > Solve_Iterative(int[] nums)
{
List <MySolution> smallerSolutions = new List <MySolution>();
int N = nums.Length;
// Build solutions of size 0.
smallerSolutions.Add(new MySolution {
List = new List <int>(),
Remaining = nums.ToList()
});
if (nums.Length == 0)
{
return(smallerSolutions.Select(s => (IList <int>)s.List).ToList());
}
List <MySolution> biggerSolutions = null;
// Build solutions of sizes 1 up to N
for (int solSize = 1; solSize <= N; solSize++)
{
biggerSolutions = new List <MySolution>();
for (int solIndex = 0; solIndex < smallerSolutions.Count; solIndex++)
{
MySolution smallerSol = smallerSolutions[solIndex];
for (int numIndex = 0; numIndex < smallerSol.Remaining.Count; numIndex++)
{
int num = smallerSol.Remaining[numIndex];
List <int> newList = new List <int>(smallerSol.List);
newList.Add(num);
List <int> newRemaining = smallerSol.Remaining.Where(n => n != num).ToList();
biggerSolutions.Add(new MySolution {
List = newList,
Remaining = newRemaining
});
}
}
smallerSolutions = biggerSolutions;
}
return(biggerSolutions.Select(s => (IList <int>)s.List).ToList());
}
public void RecursiveWordSplitTest2()
{
//Assign
var phrase = "ilovedogsJohn";
var words = new List <string>()
{
"i", "am", "a", "dogs", "lover", "love", "John"
};
var expected = new List <string>()
{
"i", "love", "dogs", "John"
};
//Act
var result = MySolution.WordSplitRecursive(phrase, words);
//Assert
CollectionAssert.AreEqual(result, expected, "Result differs from what is expected.");
}
public void IterativeOptimizedCoinChangeV3Test()
{
//Arrange
var coins = new[] { 1, 5, 10, 21, 25 };
var target = 63;
var expected = 3;
var coinUsed = new Dictionary <int, int>();
//Act
var result = MySolution.CoinChangeV3(target, coins, out coinUsed);
//Console.WriteLine("Change to give back : " + target);
//Console.WriteLine("Number of coins used : " + result);
//Console.WriteLine("Coins used : ");
//PrintUsedCoins(coinUsed, target);
//Console.ReadKey();
//Assert
Assert.AreEqual(result, expected, "Result differs from what is expected.");
}
public void RecursivePermutationTest2()
{
//Assign
var input = "1234";
var expected = new List <string>()
{
"1234",
"1243",
"1324",
"1342",
"1423",
"1432",
"2134",
"2143",
"2314",
"2341",
"2413",
"2431",
"3124",
"3142",
"3214",
"3241",
"3412",
"3421",
"4123",
"4132",
"4213",
"4231",
"4312",
"4321"
};
//Act
var result = MySolution.Perm(input);
//Assert
CollectionAssert.AreEqual(result, expected, "Result differs from what is expected.");
}
/// <summary>
/// TODO: Implement this
/// Determine where each part will fit on the given Rectangle (in testModel).
///
/// </summary>
/// <param name="test">test to evaluate</param>
/// <returns>list of complete shapes, each with where they should start</returns>
private static List <Shape> GetInsertedShapePositions(TestModel test)
{
return(MySolution.GetInsertedShapePositions(test));
}
