public void MergeIntervalsSuccess()
{
int[][] input = new int[][]
{
new int[] { 1, 3 },
new int[] { 2, 6 },
new int[] { 8, 10 },
new int[] { 15, 18 }
};
int[][] expectedResult = new int[][]
{
new int[] { 1, 6 },
new int[] { 8, 10 },
new int[] { 15, 18 }
};
var result = new MergeIntervals().Merge(input);
var isEqual = ArrayEquivalence.sequencesEqual(result, expectedResult);
Assert.IsTrue(isEqual);
}
public void IntersectionOfTwoArraysSuccess()
{
int[] input1 = new int[] { 1, 2, 2, 1 };
int[] input2 = new int[] { 2, 2 };
var expectedResult = new int[] { 2 };
var result = new IntersectionofTwoArrays().Intersection(input1, input2);
var isequal = ArrayEquivalence.sequencesEqual(result, expectedResult);
Assert.IsTrue(isequal);
input1 = new int[] { 4, 9, 5 };
input2 = new int[] { 9, 4, 9, 8, 4 };
expectedResult = new int[] { 9, 4 };
result = new IntersectionofTwoArrays().Intersection(input1, input2);
isequal = ArrayEquivalence.sequencesEqual(result, expectedResult);
Assert.IsTrue(isequal);
}
public void ProductofArrayExceptSelfSuccess()
{
int[] nums = new int[] { 1, 2, 3, 4 };
var expectedResult = new int[] { 24, 12, 8, 6 };
var result = new ProductofArrayExceptSelf().ProductExceptSelf(nums);
var isEqual = ArrayEquivalence.sequencesEqual(result, expectedResult);
Assert.IsTrue(isEqual);
}
public void MoveZerosResultsinSuccess()
{
var input = new int[] { 0, 1, 0, 3, 12 };
var expectedResult = new int[] { 1, 3, 12, 0, 0 };
new MoveZeros().MoveZeroesSolution(input);
var result = ArrayEquivalence.sequencesEqual(input, expectedResult);
Assert.IsTrue(result);
}
public void MergeSortedArraySuccess()
{
int[] nums1 = new int[] { 1, 2, 3, 0, 0, 0 };
int m = 3;
int[] nums2 = new int[] { 2, 5, 6 };
int n = 3;
int[] expectedResult = new int[] { 1, 2, 2, 3, 5, 6 };
new MergeSortedArray().Merge(nums1, m, nums2, n);
var isEqual = ArrayEquivalence.sequencesEqual(nums1, expectedResult);
Assert.IsTrue(isEqual);
}
public void CourseSchedule2_Success()
{
int[][] input = new int[][]
{
new int[] { 1, 0 },
new int[] { 2, 0 },
new int[] { 3, 1 },
new int[] { 3, 2 }
};
var expectedResult = new int[] { 0, 1, 2, 3 };
var result = new CourseSchedule2().FindOrder(4, input);
var isTrue = ArrayEquivalence.sequencesEqual(result, expectedResult);
Assert.IsTrue(isTrue);
}
public void RotateImageTests_Success()
{
var input = new int[][] {
new int[] { 1, 2, 3 },
new int[] { 4, 5, 6 },
new int[] { 7, 8, 9 }
};
var expectedResult = new int[][] {
new int[] { 7, 4, 1 },
new int[] { 8, 5, 2 },
new int[] { 9, 6, 3 }
};
new RotateImage().Rotate(input);
var areEqual = ArrayEquivalence.sequencesEqual(input, expectedResult);
Assert.IsTrue(areEqual);
}
public void WallsAndGatesResultsinSuccess()
{
var matrix = new int[4][]
{
new int[4] {
int.MaxValue, -1, 0, int.MaxValue
},
new int[4] {
int.MaxValue, int.MaxValue, int.MaxValue, -1
},
new int[4] {
int.MaxValue, -1, int.MaxValue, -1
},
new int[4] {
0, -1, int.MaxValue, int.MaxValue
}
};
var expectedResult = new int[4][]
{
new int[4] {
3, -1, 0, 1
},
new int[4] {
2, 2, 1, -1
},
new int[4] {
1, -1, 2, -1
},
new int[4] {
0, -1, 3, 4
}
};
new WallsAndGates().WallsAndGatesSolution(matrix);
var result = ArrayEquivalence.sequencesEqual(matrix, expectedResult);
Assert.IsTrue(result);
}
public void EvaluateDivision_Success()
{
IList <IList <string> > equations = new List <IList <string> >();
equations.Add(new List <string> {
"a", "b"
});
equations.Add(new List <string> {
"b", "c"
});
double[] values = new double[] { 2.0, 3.0 };
IList <IList <string> > queries = new List <IList <string> >();
queries.Add(new List <string> {
"a", "c"
});
queries.Add(new List <string> {
"b", "a"
});
queries.Add(new List <string> {
"a", "e"
});
queries.Add(new List <string> {
"a", "a"
});
queries.Add(new List <string> {
"x", "x"
});
double[] expectedResult = new double[] { 6.0, 0.5, -1.0, 1.0, -1.0 };
var result = new EvaluateDivision().CalcEquation(equations, values, queries);
var isEqual = ArrayEquivalence.sequencesEqual(result, expectedResult);
Assert.IsTrue(isEqual);
}
public void NextPermutationSuccess()
{
int[] input = new int[] { 1, 2, 3 };
int[] expectedResult = new int[] { 1, 3, 2 };
new NextPermutationSolution().NextPermutation(input);
bool isEqual = ArrayEquivalence.sequencesEqual(input, expectedResult);
Assert.IsTrue(isEqual);
input = new int[] { 3, 2, 1 };
expectedResult = new int[] { 1, 2, 3 };
new NextPermutationSolution().NextPermutation(input);
isEqual = ArrayEquivalence.sequencesEqual(input, expectedResult);
Assert.IsTrue(isEqual);
input = new int[] { 1, 1, 5 };
expectedResult = new int[] { 1, 5, 1 };
new NextPermutationSolution().NextPermutation(input);
isEqual = ArrayEquivalence.sequencesEqual(input, expectedResult);
Assert.IsTrue(isEqual);
}
