public void GetLongestEqualSubseq_EmptyList()
{
List <int> seq = new List <int>();
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(0, longestEqualSubseq.Count);
}
static void Main()
{
string input = Console.ReadLine();
LongestSubsequence lS = new LongestSubsequence();
lS.Find(input);
}
public void SubsequenceEmpty()
{
List <int> numbers = new List <int> {
};
List <int> subSequence =
LongestSubsequence.FindLongestSubsequence(numbers);
}
public void FindLongestSubsequence_EmptyList_ShouldReturnEmptyList()
{
var list = new List <int>(); // Should return empty list
var expected = new List <int>();
var result = LongestSubsequence.FindLongestSubsequence(list);
CollectionAssert.AreEqual(expected, result);
}
public void GetLongestEqualSubseq_TwoSameValues()
{
List <int> seq = new List <int> {
3, 3
};
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(2, longestEqualSubseq.Count);
CollectionAssert.AreEqual(seq, longestEqualSubseq);
}
public void GetLongestEqualSubseq_TwoDifferentValues()
{
List <int> seq = new List <int> {
4, 5
};
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(1, longestEqualSubseq.Count);
Assert.AreEqual(4, longestEqualSubseq[0]);
}
public void GetLongestEqualSubseq_SingleValue()
{
List <int> seq = new List <int>();
seq.Add(5);
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(1, longestEqualSubseq.Count);
CollectionAssert.AreEqual(seq, longestEqualSubseq);
}
public void SingleInputShouldReturnSingleOutput()
{
List <int> list = new List <int>
{
0
};
list = LongestSubsequence.CalculateLongestSubsequence(list);
Assert.AreEqual(0, list[0]);
Assert.AreEqual(1, list.Count);
}
public void FindingSubsequenceInTheBeginningOfTheListShouldWork()
{
var testList = new List <int> {
1, 1, 1, 1, 1, 2, 2, 2, 0, 0, 0, 0
};
var result = LongestSubsequence.FindLongestSubsequence(testList);
CollectionAssert.AreEqual(new List <int> {
1, 1, 1, 1, 1
}, result);
}
public void GetLongestEqualSubseq_MultipleValuesTest5()
{
List <int> seq = new List <int> {
5, 5, 5, 6, 6, 3, 7, 13, 7, 5, 5, 6, 6, 6, 6, 6
};
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(5, longestEqualSubseq.Count);
CollectionAssert.AreEqual(new List <int> {
6, 6, 6, 6, 6
}, longestEqualSubseq);
}
public void GetLongestEqualSubseq_MultipleValuesTest4()
{
List <int> seq = new List <int> {
1, 1, 1, 1, 5, 5, 5, 6, 7, 5, 5
};
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(4, longestEqualSubseq.Count);
CollectionAssert.AreEqual(new List <int> {
1, 1, 1, 1
}, longestEqualSubseq);
}
public void FindingSubsequenceShouldWorkWithNegativeNumbers()
{
var testList = new List <float> {
1, 2, 4, 4, 4, 2, -0.5f, -0.5f, -0.5f, -0.5f
};
var result = LongestSubsequence.FindLongestSubsequence(testList);
CollectionAssert.AreEqual(new List <float> {
-0.5f, -0.5f, -0.5f, -0.5f
}, result);
}
public void FindingSubsequenceInTheMiddleOfTheListShouldWork()
{
var testList = new List <decimal> {
1, 2, 4, 4, 4, 4, 4, 4, 2, 0.5m, 0.5m, 0.5m, 0.5m
};
var result = LongestSubsequence.FindLongestSubsequence(testList);
CollectionAssert.AreEqual(new List <decimal> {
4, 4, 4, 4, 4, 4
}, result);
}
public void FindingSubsequenceInTheEndOfTheListShouldWork()
{
var testList = new List <double> {
1, 2, 2, 0.5, 0.5, 0.5, 0.5
};
var result = LongestSubsequence.FindLongestSubsequence(testList);
CollectionAssert.AreEqual(new List <double> {
0.5, 0.5, 0.5, 0.5
}, result);
}
public void GetLongestEqualSubseq_MultipleValuesTest1()
{
List <int> seq = new List <int> {
4, -3, 5, 5, 5, 7, 7
};
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(3, longestEqualSubseq.Count);
CollectionAssert.AreEqual(new List <int> {
5, 5, 5
}, longestEqualSubseq);
}
public void GetLongestEqualSubseq_OneDiffTwoSameValues()
{
List <int> seq = new List <int> {
2, 1, 1
};
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(2, longestEqualSubseq.Count);
CollectionAssert.AreEqual(new List <int> {
1, 1
}, longestEqualSubseq);
}
public void GetLongestEqualSubseq_NoEqualNeighbours()
{
List <int> seq = new List <int> {
1, -3, 1, 4, 5, 3, 5, 7
};
List <int> longestEqualSubseq = LongestSubsequence.GetLongestEqualSubseq(seq);
Assert.AreEqual(1, longestEqualSubseq.Count);
CollectionAssert.AreEqual(new List <int> {
1
}, longestEqualSubseq);
}
public void MaxSequenceOfEquals_GenericTest()
{
List <int> actual = LongestSubsequence.MaxSequenceOfEquals(new List <int>()
{
1, 12, 1, 3, 4, 2, 2, 2, 1, 2, 1, 2, 1
});
List <int> expected = new List <int>()
{
2, 2, 2
};
CollectionAssert.AreEqual(expected, actual);
}
public void MaxSequenceOfEquals_OneElementTest()
{
List <int> actual = LongestSubsequence.MaxSequenceOfEquals(new List <int>()
{
1
});
List <int> expected = new List <int>()
{
1
};
CollectionAssert.AreEqual(expected, actual);
}
public void MaxSequenceOfEquals_BeginningTest()
{
List <int> actual = LongestSubsequence.MaxSequenceOfEquals(new List <int>()
{
1, 1, 1, 3, 4, 2, 2, 42, 2, 2, 33, 1, 1
});
List <int> expected = new List <int>()
{
1, 1, 1
};
CollectionAssert.AreEqual(expected, actual);
}
public void SubsequenceNormalTest()
{
var sequence = new List <int>()
{
2, 3, 4, 3, 3, 2, 4, 3
};
var expected = new List <int>()
{
3, 3
};
var actual = LongestSubsequence.GetLongestSubsequence(sequence);
CollectionAssert.AreEqual(expected, actual);
}
public void FindsTheLongestSubsequenceOfEqualNumbers()
{
var numbers = new List <int> {
12, 2, 2, 2, 3, 5, 9, 4, 4, 4, 4
};
var expected = new List <int> {
4, 4, 4, 4
};
var actual = LongestSubsequence.FindsTheLongestSubsequenceOfEqualNumbers(numbers);
CollectionAssert.AreEqual(expected, actual);
}
public void TestFindLongestSubsequence()
{
List <int> numbers = new List <int> {
9, 5, -3, 6, -8, 5, -5, 21, 5, 6, -5, 8, -6
};
//List<int> expectedList = new List<int>{ 5, 5, 5 };
List <int> tested = LongestSubsequence.FindLongestSubsequence(numbers);
Assert.IsTrue(tested.Count == 3);
for (int i = 0; i < tested.Count; i++)
{
Assert.AreEqual(5, tested[i]);
}
}
public void FindLongestSubsequence_1Element_ShouldReturnCorrectly()
{
var list = new List <int>()
{
1
}; // Should return 1
var expected = new List <int>()
{
1
};
var result = LongestSubsequence.FindLongestSubsequence(list);
CollectionAssert.AreEqual(expected, result);
}
public void FindLongestSubsequence_MoreThanOneLongest_ShouldFindLeftmost()
{
var list = new List <int>()
{
69, 69, 1, 1, 2, 2, 3, 3
}; // Should return 2 x 69
var expected = new List <int>()
{
69, 69
};
var result = LongestSubsequence.FindLongestSubsequence(list);
CollectionAssert.AreEqual(expected, result);
}
public void FindLongestSubsequence_SequenceAtTheEnd_ShouldFindCorrectly()
{
var list = new List <int>()
{
504, 504, 2, 2, 3, 3, 3, 3, 78, 78, 78, 78, 78, 78, 78, 104, 1004, 2, 2, 2, 2, 2, 2, 2, 2
}; // Should return 8 x 2
var expected = new List <int>()
{
2, 2, 2, 2, 2, 2, 2, 2
};
var result = LongestSubsequence.FindLongestSubsequence(list);
CollectionAssert.AreEqual(expected, result);
}
public void FindLongestSubsequence_SequenceInTheMIddle_ShouldFindCorrectly()
{
var list = new List <int>()
{
1, 1, 1, 5, 5, 69, 69, 2, 504, 504, 2, 2, 3, 3, 3, 3, 78, 78, 78, 78, 78, 78, 78, 104, 1004
}; // Should return 7 x 78
var expected = new List <int>()
{
78, 78, 78, 78, 78, 78, 78
};
var result = LongestSubsequence.FindLongestSubsequence(list);
CollectionAssert.AreEqual(expected, result);
}
public void TestNoneValueMatrix()
{
List <int> unsortedList = new List <int>()
{
};
var actual = LongestSubsequence.GetLongestEqualSubseq(unsortedList);
var expected = new List <int>()
{
};
for (int i = 0; i < expected.Count; i++)
{
Assert.AreEqual(expected[i], actual[i]);
}
}
public void SubsequenceCount1()
{
List <int> numbers = new List <int> {
4
};
List <int> subSequence =
LongestSubsequence.FindLongestSubsequence(numbers);
foreach (var number in subSequence)
{
Assert.AreEqual(4, number);
}
Assert.AreEqual(1, subSequence.Count);
}
public void RepeatedLongestSequenceInput()
{
List <int> list = new List <int>
{
0, 2, 2, 2, 5, 5, 5, 2, 2, 2, 12
};
list = LongestSubsequence.CalculateLongestSubsequence(list);
List <int> test = new List <int>
{
2, 2, 2
};
Assert.IsTrue(list.SequenceEqual(test));
}
public static void Main(string[] args)
{
SumAndAverage.CalculateSumAndAverage();
StackReverse.Reverse();
SortList.Sort();
LongestSubsequence.FindLongestSubsequence();
NegativeRemoval.Remove();
OddOccurenceRemoval.Remove();
OccurenceCounter.Count();
Majorant.FindMajorant();
SequenceMemberFinder.Find();
ShortestSequenceOfOperations.Find();
Client.Print();
ClientAdtClient.Operate();
ClientAdtQueue.Operate();
}
