public void PrettyPrintTest()
{
int n = 3;
var expected = new List <List <int> >
{
new List <int> {
3, 3, 3, 3, 3
},
new List <int> {
3, 2, 2, 2, 3
},
new List <int> {
3, 2, 1, 2, 3
},
new List <int> {
3, 2, 2, 2, 3
},
new List <int> {
3, 3, 3, 3, 3
},
};
var result = ArraysAndStrings.PrettyPrint(n);
Assert.AreEqual(expected.Count, result.Count);
for (int i = 0; i < expected.Count; i++)
{
CollectionAssert.AreEqual(expected[i], result[i]);
}
}
public void SpellcheckerTest1()
{
string[] wordlist = { "KiTe", "kite", "hare", "Hare" };
string[] queries = { "kite", "Kite", "KiTe", "Hare", "HARE", "Hear", "hear", "keti", "keet", "keto" };
string[] expected = { "kite", "KiTe", "KiTe", "Hare", "hare", "", "", "KiTe", "", "KiTe" };
CollectionAssert.AreEqual(expected, ArraysAndStrings.Spellchecker(wordlist, queries));
}
public void IsUnique_NotUniqueCase()
{
string notUniqueWord = "ZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
bool result = ArraysAndStrings.IsUnique(notUniqueWord);
Assert.IsFalse(result, "Non-unique test case evaulated as unique.");
}
public void IsUnique_UniqueCase()
{
string uniqueWord = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
bool result = ArraysAndStrings.IsUnique(uniqueWord);
Assert.IsTrue(result, "Unique test case evaulated as not unique.");
}
public void FlattenDictionaryTest3()
{
var inputDict = new Dictionary <string, object>
{
{ "key1", "1" },
{ "", new Dictionary <string, object>()
{
{ "key12", "24" },
{ "key23", new Dictionary <string, object>()
{
{ "a", "345" },
{ "b", "346" }
} }
} }
};
var expectedDict = new Dictionary <string, string>
{
{ "key1", "1" },
{ "key12", "24" },
{ "key23.a", "345" },
{ "key23.b", "346" }
};
CollectionAssert.AreEqual(expectedDict, ArraysAndStrings.FlattenDictionary(inputDict));
}
public void CheckPermutation_IsNotPermutationCase()
{
string word1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string word2 = "zYXWVUTSRQPONMLKJIHGFEDCBA";
bool result = ArraysAndStrings.CheckPermutation(word1, word2);
Assert.IsFalse(result, "Failed false permutation case.");
}
public void FlattenDictionaryTest1()
{
var inputDict = new Dictionary <string, object>();
inputDict.Add("key1", "1");
var expectedDict = new Dictionary <string, string>();
expectedDict.Add("key1", "1");
CollectionAssert.AreEqual(expectedDict, ArraysAndStrings.FlattenDictionary(inputDict));
}
public void IsUnique2TestInputIsValidAndUniqiue()
{
// Arrange
String input = "chant";
bool expected = true;
// Act
var actual = ArraysAndStrings.IsUnique(input);
// Assert
Assert.AreEqual(expected, actual);
}
public void MeetingPlannerTest5()
{
var slotA = new[, ] {
{ 10, 50 }, { 60, 120 }, { 140, 210 }
};
var slotB = new[, ] {
{ 0, 15 }, { 60, 70 }
};
int dur = 8;
CollectionAssert.AreEqual(new[] { 60, 68 }, ArraysAndStrings.MeetingPlanner(slotA, slotB, dur));
}
public void MeetingPlannerTest4()
{
var slotA = new[, ] {
{ 0, 5 }, { 50, 70 }, { 120, 125 }
};
var slotB = new[, ] {
{ 0, 50 }
};
int dur = 8;
CollectionAssert.AreEqual(new int[0], ArraysAndStrings.MeetingPlanner(slotA, slotB, dur));
}
public void MeetingPlannerTest3()
{
var slotA = new[, ] {
{ 1, 10 }
};
var slotB = new[, ] {
{ 2, 3 }, { 5, 7 }
};
int dur = 2;
CollectionAssert.AreEqual(new[] { 5, 7 }, ArraysAndStrings.MeetingPlanner(slotA, slotB, dur));
}
public void MeetingPlannerTest2()
{
var slotA = new[, ] {
{ 6, 12 }
};
var slotB = new[, ] {
{ 2, 11 }
};
int dur = 5;
CollectionAssert.AreEqual(new[] { 6, 11 }, ArraysAndStrings.MeetingPlanner(slotA, slotB, dur));
}
public void IsUnique2TestInputIsValidAndNotUniqiue()
{
// Arrange
String input = "manhattan";
bool expected = false;
// Act
var actual = ArraysAndStrings.IsUnique(input);
// Assert
Assert.AreEqual(expected, actual);
}
public void ArrayManipulationTest()
{
int n = 5;
int[][] queries =
{
new[] { 1, 2, 100 },
new[] { 2, 5, 100 },
new[] { 3, 4, 100 },
};
Assert.AreEqual(200, ArraysAndStrings.ArrayManipulation(n, queries));
}
private void MinimumBribeTestHelper(int[] input, string expected)
{
// Needed to test a method which writes to the Console to validate the output
var currentConsoleOut = Console.Out;
using (var consoleOutput = new ConsoleOutput())
{
ArraysAndStrings.MinimumBribes(input);
Assert.AreEqual(expected + "\r\n", consoleOutput.GetOuput());
}
Assert.AreEqual(currentConsoleOut, Console.Out);
}
public void IsUnique2TestInputIsNullOrWhitespace()
{
// Arrange
String input = " ";
// Act
try
{
var actual = ArraysAndStrings.IsUnique2(input);
}
catch (Exception ex)
{
// Assert
Assert.AreEqual("Please enter a non-empty string.", ex.Message);
throw;
}
}
public void IsPermutationTestFirstInputIsNullOrWhitespace()
{
// Arrange
String string1 = null;
String string2 = "boot";
// Act
try
{
var actual = ArraysAndStrings.IsPermutation(string1, string2);
}
catch (Exception ex)
{
// Assert
Assert.AreEqual("Please enter a non-empty string.", ex.Message);
throw;
}
}
public void MatrixRotation(string inputString, string resultString)
{
int[][] input = convertToArray(inputString);
Trace.WriteLine("Input:");
printMatrix(input);
ArraysAndStrings.MatrixRotation(input);
Trace.WriteLine("Result");
printMatrix(input);
int[][] result = convertToArray(resultString);
for (int i = 0; i < input.Length; i++)
{
for (int j = 0; j < input[i].Length; j++)
{
Assert.AreEqual(input[i][j], result[i][j]);
}
}
}
public void StringCompression(string input, string result)
{
Assert.AreEqual(result, ArraysAndStrings.StringCompression(input));
}
public void IsPalindromePermutation(string s, bool result)
{
Assert.AreEqual(result, ArraysAndStrings.IsPalindromePermutation(s));
}
public void OneEditAway(string s1, string s2, bool result)
{
Assert.AreEqual(result, ArraysAndStrings.OneEditAway(s1, s2));
}
public void IsPermutation(string a, string b, bool expected)
{
Assert.AreEqual(expected, ArraysAndStrings.CheckPermutation(a, b));
}
public void URLfy(string s, int length, string result)
{
Assert.AreEqual(result, ArraysAndStrings.URLify(s, length));
}
public void IsRotation(string s1, string s2, bool expected)
{
bool result = ArraysAndStrings.IsRotation(s1, s2);
Assert.AreEqual(expected, result);
}
public void IsUnique(string a, bool expected)
{
Assert.AreEqual(expected, ArraysAndStrings.IsUnique(a));
}
static void Main(string[] args)
{
// tuple try
Tuple <int, string, bool> tuple = new Tuple <int, string, bool>(1, "cat", true);
var tuple2 = Tuple.Create("cat", 2, true);
Console.WriteLine($"IsUnique: result={ArraysAndStrings.IsStringUnique("dFf")}, expected=True");
Console.WriteLine($"CheckPermutation: result={ArraysAndStrings.CheckPermutation("abcb","cbba")}, expected=True");
Console.WriteLine($"IsPalindromePermutation: result={ArraysAndStrings.IsPalindromePermutation("Tact coa")}, expected=True");
Console.WriteLine($"IsPalindromePermutation: result={ArraysAndStrings.IsPalindromePermutation("bbcc bc")}, expected=False");
Console.WriteLine($"IsOneAway: result={ArraysAndStrings.IsOneAway("pale", "ple")}, expected=True");
Console.WriteLine($"IsPrime(\"a\"): result={ArraysAndStrings.IsPrime("a")}, expected=True");
Console.WriteLine($"IsPrime(\"aaa\"): result={ArraysAndStrings.IsPrime("aaa")}, expected=False");
Console.WriteLine($"IsPrime(\"aaab\"): result={ArraysAndStrings.IsPrime("aaab")}, expected=True");
Console.WriteLine($"IsPrime(\"abcabc\"): result={ArraysAndStrings.IsPrime("abcabc")}, expected=False");
Console.WriteLine($"IsPrime(\"ababab\"): result={ArraysAndStrings.IsPrime("ababab")}, expected=False");
QueueViaStacks <int> queueViaStacks = new QueueViaStacks <int>();
queueViaStacks.Enqueue(1);
queueViaStacks.Enqueue(2);
Console.WriteLine($"QueueViaStacks: result={queueViaStacks.Dequeue()}, expected=1");
queueViaStacks.Enqueue(3);
Console.WriteLine($"QueueViaStacks: result={queueViaStacks.Peek()}, expected=2");
Console.WriteLine($"QueueViaStacks: result={queueViaStacks.Dequeue()}, expected=2");
Console.WriteLine($"QueueViaStacks: result={queueViaStacks.Dequeue()}, expected=3");
var mat1 = new[, ] {
{ 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 }
};
Console.WriteLine($"RotateMatrix: result=[\n{ArraysAndStrings.MatrixToString(mat1)}], expected=[\n[13, 9, 5, 1],\n[14,10, 6, 2],\n[15,11, 7, 3],\n[16,12, 8, 4]\n]");
var res01 = Trees.ListOfDepths(Trees.CreateBinaryTree(new int?[] { 3, 9, 20, null, null, 15, 7 }));
Console.WriteLine($"result=[[{res01[0].First.Value.Val}],[{res01[1].First.Value.Val},{res01[1].Last.Value.Val}],[{res01[2].First.Value.Val},{res01[2].Last.Value.Val}]],expected = [[3],[9,20],[15,7]]");
Console.WriteLine($"CheckBalanced: result={Trees.CheckBalanced(Trees.CreateBinaryTree(new int?[] { 3, 9, 20, null, null, 15, 7 }))}, expected=True");
Console.WriteLine($"CheckBalanced: result={Trees.CheckBalanced(Trees.CreateBinaryTree(new int?[] { 3, null }))}, expected=True");
Console.WriteLine($"CheckBalanced: result={Trees.CheckBalanced(Trees.CreateBinaryTree(new int?[] { 3, null, 20, 15 }))}, expected=False");
ArraysAndStrings.ArrayInitializations();
Console.WriteLine($"CanBeWrittenFrom: result={ArraysAndStrings.CanBeWrittenFrom("a,O,","qpz,,%ar0O")}, expected=True");
Console.WriteLine($"CanBeWrittenFrom: result={ArraysAndStrings.CanBeWrittenFrom("a,O,", "qpz,%ar0O")}, expected=False");
Console.WriteLine($"CanBeWrittenFrom: result={ArraysAndStrings.CanBeWrittenFrom("abba", "Banda b")}, expected=False");
Console.WriteLine($"WordCountEngine: result=[{ArraysAndStrings.MatrixToString(ArraysAndStrings.WordCountEngine("Practice makes perfect, you'll get perfecT by practice. just practice! just just just!!"))}], expected=[[\"just\",\"4\"],[\"practice\",\"3\"],[\"perfect\",\"2\"],[\"makes\",\"1\"],[\"youll\",\"1\"],[\"get\",\"1\"],[\"by\",\"1\"]]");
Console.WriteLine($"WordCountEngine: result=[{ArraysAndStrings.MatrixToString(ArraysAndStrings.WordCountEngine("Every book is a quotation; and every house is a quotation out of all forests, and mines, and stone quarries; and every man is a quotation from all his ancestors. "))}], expected=[[\"and\",\"4\"],[\"every\",\"3\"],[\"is\",\"3\"],[\"a\",\"3\"],[\"quotation\",\"3\"],[\"all\",\"2\"],[\"book\",\"1\"],[\"house\",\"1\"],[\"out\",\"1\"],[\"of\",\"1\"],[\"forests\",\"1\"],[\"mines\",\"1\"],[\"stone\",\"1\"],[\"quarries\",\"1\"],[\"man\",\"1\"],[\"from\",\"1\"],[\"his\",\"1\"],[\"ancestors\",\"1\"]]");
Console.WriteLine($"ReverseWords: result=[{new string(ArraysAndStrings.ReverseWords(new char[] { 'y', 'o', 'u', ' ', 'm', 'e' }))}], expected=[me you]");
Console.WriteLine($"MeetingPlanner: result=[{ArraysAndStrings.MeetingPlanner(new[,] { {7,12 }}, new[,] { { 2, 11 } },5)}], expected = []");
Console.WriteLine($"IsMatchRegex: result={ArraysAndStrings.IsMatchRegex("abaa", "a.*a*")}, expected = True");
Console.WriteLine($"GetShortestUniqueSubstring: result={ArraysAndStrings.GetShortestUniqueSubstring(new[] { 'a','b'}," - acb ")}, expected = acb");
Console.WriteLine($"GetShortestUniqueSubstring: result=[{ArraysAndStrings.ArrayToString(ArraysAndStrings.FindArrayQuadruplet(new[] { 2, 7, 4, 0, 9, 5, 1, 3 }, 20))}], expected = [0, 4, 7, 9]");
Console.WriteLine($"GetShortestUniqueSubstring: result={MathAndLogicPuzzles.RootOfNumber(27,3)}, expected = 3.0");
Console.WriteLine($"NumOfPathsToDest: result={ArraysAndStrings.NumOfPathsToDest(4)}, expected = 5");
Console.WriteLine($"IsContainSubstringPermutation: result={ArraysAndStrings.IsContainSubstringPermutation3("dcda", "adc")}, expected = True");
Console.ReadLine();
}
public void MinWindowTest7()
{
Assert.AreEqual("BANC", ArraysAndStrings.MinWindow("ADOBECODEBANC", "ABC"));
}
public void MinWindowTest6()
{
Assert.AreEqual("ksfor", ArraysAndStrings.MinWindow("geeksforgeeks", "ork"));
}
public void MinWindowTest5()
{
Assert.AreEqual("t stri", ArraysAndStrings.MinWindow("this is a test string", "tist"));
}
public void MinWindowTest4()
{
Assert.AreEqual("", ArraysAndStrings.MinWindow("bac", "cac"));
}
