public void ZeroSizeInput()
{
var input = new int[0][];
var result = NumberOfIslands.Run(input);
Assert.AreEqual(0, result);
}
public void NullInput()
{
int[][] input = null;
var result = NumberOfIslands.Run(input);
Assert.AreEqual(0, result);
}
public void TestSolution(char[,] grid, int expectedNumber)
{
var solution = new NumberOfIslands();
var actualNumber = solution.NumIslands(grid);
actualNumber.Should().Be(expectedNumber);
}
static void Main(string[] args)
{
NumberOfIslands number = new NumberOfIslands();
Console.WriteLine(number.IslandCount());
SpiralPrint sp = new SpiralPrint();
sp.Print();
PascalTriangle pt = new PascalTriangle();
pt.Generate(6); pt.Print();
MedianOfSortedArrays ms = new MedianOfSortedArrays();
Console.WriteLine(ms.MedianOf2SortedArrays(ms.array1, ms.array2));
FindtheMissingNumber fn = new FindtheMissingNumber();
Console.WriteLine(fn.FindtheMissingNumberMethod1());
ContainsDuplicate cd = new ContainsDuplicate();
Console.WriteLine(cd.isDuplicateMethod2());
ReversedLinkedList rl = new ReversedLinkedList();
rl.reversedList();
ReverseNumber rn = new ReverseNumber();
rn.ReverseANumber(12345);
LinearSearch ls = new LinearSearch();
BinarySearch bs = new BinarySearch();
ZigZag zz = new ZigZag();
Console.WriteLine(zz.Convert("PAYPALISHIRING", 3));
BinaryTree bt = new BinaryTree();
bt.InorderTraverse(bt.root);
Console.WriteLine();
bt.PreorderTraverse(bt.root);
Console.WriteLine();
bt.PostorderTraverse(bt.root);
RotateArray ra = new RotateArray(3);
//SearchRotatedArray sr = new SearchRotatedArray(3);
//Console.WriteLine(sr.Find());
FindSumSarray fS = new FindSumSarray();
MaxSumSubArray mxSum = new MaxSumSubArray();
}
void InternalTest(char[][] grid, int expected)
{
char[][] clone = CloneGrid(grid);
int actual = NumberOfIslands.BFSNumIslands(grid);
Assert.Equal <int>(expected, actual);
actual = NumberOfIslands.DFSNumIslands(clone);
Assert.Equal <int>(expected, actual);
}
public void Size1X0Input()
{
var input = new[]
{
new int[0]
};
var result = NumberOfIslands.Run(input);
Assert.AreEqual(0, result);
}
public void NumIslandsTestCase2()
{
var input = new [] {
new [] { '1', '1', '0', '0', '0' },
new [] { '1', '1', '0', '0', '0' },
new [] { '0', '0', '1', '0', '0' },
new [] { '0', '0', '0', '1', '1' }
};
NumberOfIslands.NumIslands(input).Should().Be(3);
}
public void OneIslandTurnLeft()
{
var input = new[]
{
new [] { 1, 1 },
new [] { 0, 1 }
};
var result = NumberOfIslands.Run(input);
Assert.AreEqual(1, result);
}
public void Test9()
{
//Given
char[][] input = new char[][] { };
//When
var sut = new NumberOfIslands();
int num = sut.NumIslands(input);
//Then
num.Should().Be(0);
}
public void CountIslandsTest()
{
var grid = new char[, ]
{
{ '1', '1', '0', '0', '0' },
{ '1', '1', '0', '0', '0' },
{ '0', '0', '1', '0', '0' },
{ '0', '0', '0', '1', '1' }
};
Assert.AreEqual(3, NumberOfIslands.NumIslands(grid));
}
public void NumberOfIslands()
{
NumberOfIslands NumberOfIslands = new NumberOfIslands();
char[][] grid = new char[4][];
grid[0] = new char[] { '1', '1', '1', '1', '0' };
grid[1] = new char[] { '1', '1', '0', '1', '0' };
grid[2] = new char[] { '1', '1', '0', '0', '0' };
grid[3] = new char[] { '0', '0', '0', '0', '1' };
int answer = NumberOfIslands.NumIslands(grid);
}
public static void Main(string[] args)
{
NumberOfIslands ns = new NumberOfIslands();
char[,] M = new char[, ] {
{ '1', '1', '0', '0', '0' },
{ '1', '1', '0', '0', '0' },
{ '0', '0', '1', '0', '0' },
{ '0', '0', '0', '1', '1' }
};
int result = ns.NumIslands(M);
}
public void ThreeIslands()
{
var input = new[]
{
new [] { 1, 1, 0, 0, 0, 0, 0 },
new [] { 1, 1, 0, 0, 0, 0, 0 },
new [] { 0, 0, 1, 0, 0, 0, 0 },
new [] { 0, 0, 0, 1, 1, 1, 1 },
new [] { 0, 0, 0, 1, 1, 1, 1 },
new [] { 0, 0, 0, 1, 1, 1, 1 }
};
var result = NumberOfIslands.Run(input);
Assert.AreEqual(3, result);
}
public void Test5()
{
//Given
char[][] input = new char[][] {
new char[] { '0', '0', '0' },
new char[] { '0', '1', '0' },
new char[] { '0', '0', '0' }
};
//When
var sut = new NumberOfIslands();
int num = sut.NumIslands(input);
//Then
num.Should().Be(1);
}
public void NumIslandsTest()
{
char[][] grid1 = new char[][] { new char[] { '1', '1', '1', '1', '0' },
new char[] { '1', '1', '0', '1', '0' },
new char[] { '1', '1', '0', '0', '0' },
new char[] { '0', '0', '0', '0', '0' }, };
int output = 1;
char[][] grid2 = new char[][] { new char[] { '1', '1', '0', '0', '0' },
new char[] { '1', '1', '0', '0', '0' },
new char[] { '0', '0', '1', '0', '0' },
new char[] { '0', '0', '0', '1', '1' }, };
int output2 = 3;
Assert.AreEqual(NumberOfIslands.NumIslands(grid2), output2);
}
private static int LeetCode_NumberOfIslands()
{
char[][] grid = new char[][]
{
new char[] { '1', '1', '0', '0', '0' },
new char[] { '1', '1', '0', '0', '0' },
new char[] { '0', '0', '1', '0', '0' },
new char[] { '0', '0', '0', '1', '1' }
};
NumberOfIslands num = new NumberOfIslands();
int iCount = num.NumIslands(grid);
Console.Write(iCount);
Console.ReadLine();
return(0);
}
public void NumsIslandResultsInSuccess()
{
char[][] island = new char[][] {
new char[] { '1', '1', '0', '0', '0' },
new char[] { '1', '1', '0', '0', '0' },
new char[] { '0', '0', '1', '0', '0' },
new char[] { '0', '0', '0', '1', '1' }
};
var expectedResult = 3;
var result = new NumberOfIslands().NumIslands(island);
Assert.AreEqual(result, expectedResult);
}
public void Setup()
{
solution = new NumberOfIslands();
}
static void Main(string[] args)
{
#region 1. Two Sum
TwoSums twoSums = new TwoSums(new int[] { 2, 7, 11, 15 }, 18);
twoSums.PrintExample();
#endregion
#region 3. LongestSubstringWithoutRepeatingCharacters
LongestSubstringWithoutRepeatingCharacters longestSubstringWithoutRepeating = new LongestSubstringWithoutRepeatingCharacters("abcdecb");
longestSubstringWithoutRepeating.PrintExample();
#endregion
#region 7. Reverse Integer
ReverseInteger reverseInteger = new ReverseInteger(-54321);
reverseInteger.PrintExample();
#endregion
#region 8. String to Integer (atoi)
StringToInteger stringToInteger = new StringToInteger(" -42");
stringToInteger.PrintExample();
#endregion
#region 9. Palindrome Number
PalindromeNumber palindromeNumber = new PalindromeNumber(121);
palindromeNumber.PrintExample();
#endregion
#region 20. Valid Parentheses
ValidParentheses validParentheses = new ValidParentheses("(){[]}");
validParentheses.PrintExample();
#endregion
#region 26. Remove Duplicates from Sorted Array
RemoveDuplicatesFromSortedArray removeDuplicatesFromSortedArray = new RemoveDuplicatesFromSortedArray(new [] { 1, 2, 3, 3, 4, 5, 5, 5, 5, 5, 5, 6 });
removeDuplicatesFromSortedArray.PrintExample();
#endregion
#region 35. Search Insert Position
SearchInsertPosition searchInsertPosition = new SearchInsertPosition(new [] { 1, 3, 5, 10 }, 9);
searchInsertPosition.PrintExample();
#endregion
#region 58. Length of Last Word
LengthOfLastWord lengthOfLastWord = new LengthOfLastWord("Hello World");
lengthOfLastWord.PrintExample();
#endregion
#region 104. Maximum Depth of Binary Tree
#endregion
#region 125. Valid Palindrome
ValidPalindrome validPalindrome = new ValidPalindrome("A man, a plan, a canal: Panama");
validPalindrome.PrintExample();
#endregion
#region 136. Single Number
SingleNumber singleNumber = new SingleNumber(new [] { 2, 2, 3, 3, 1 });
singleNumber.PrintExample();
#endregion
#region 150. Evaluate Reverse Polish Notation
EvaluateReversePolishNotation evaluateReversePolishNotation = new EvaluateReversePolishNotation(new [] { "2", "1", "+", "3", "*" });
evaluateReversePolishNotation.PrintExample();
#endregion
#region 155. Min Stack
MinStack minStack = new MinStack();
minStack.PrintExample();
#endregion
#region 167. Two Sum II - Input array is sorted
TwoSumII twoSumII = new TwoSumII(new [] { 1, 2, 3, 7 }, 10);
twoSumII.PrintExample();
#endregion
#region 200. Number of Islands
NumberOfIslands numberOfIslands = new NumberOfIslands(new char[, ]
{
{ '1', '1', '0', '0', '0' },
{ '1', '1', '0', '0', '0' },
{ '0', '0', '1', '0', '0' },
{ '0', '0', '0', '1', '1' }
});
numberOfIslands.PrintExample();
#endregion
#region 217. Contains Duplicate
ContainsDuplicate containsDuplicate = new ContainsDuplicate(new [] { 1, 2, 3, 1 });
containsDuplicate.PrintExample();
#endregion
#region 268. Missing Number
MissingNumber missingNumber = new MissingNumber(new [] { 9, 6, 4, 2, 3, 5, 7, 0, 1 });
missingNumber.PrintExample();
#endregion
#region 344. Reverse String
ReverseString reverseString = new ReverseString("A man with a plan");
reverseString.PrintExample();
#endregion
#region 387. First Unique Character in a String
FirstUniqueCharacterInAString firstUniqueChar = new FirstUniqueCharacterInAString("loveleetcode");
firstUniqueChar.PrintExample();
#endregion
#region 412. FizzBuzz
FizzBuzz fizzBuzz = new FizzBuzz(15);
fizzBuzz.PrintExample();
#endregion
#region 485. Max Consecutive Ones
MaxConsecutiveOnes maxConsecutiveOnes = new MaxConsecutiveOnes(new int[] { 1, 1, 0, 1, 1, 1 });
maxConsecutiveOnes.PrintExample();
#endregion
#region 509. Fibonacci Number
FibonacciNumber fibonacciNumber = new FibonacciNumber(10);
fibonacciNumber.PrintExample();
#endregion
#region 622. Design Circular Queue
CircularQueue circularQueue = new CircularQueue(1);
Console.WriteLine("622. Design Circular Queue");
Console.WriteLine($"Front() : {circularQueue.Front()}");
Console.WriteLine($"IsEmpty() : {circularQueue.IsEmpty()}");
circularQueue.EnQueue(1);
Console.WriteLine($"EnQueue(1)");
Console.WriteLine($"IsEmpty() : {circularQueue.IsEmpty()}");
Console.WriteLine($"IsFull() : {circularQueue.IsFull()}\n");
#endregion
#region 707. Design Linked List
LinkedList linkedList = new LinkedList(new Node());
linkedList.AddAtTail(10);
linkedList.AddAtTail(20);
linkedList.PrintLinkedList();
#endregion
#region 709. To Lower Case
ToLowerCase toLowerCase = new ToLowerCase("LOVELY");
toLowerCase.PrintExample();
#endregion
#region 739. Daily Temperatures
DailyTemperatures dailyTemperatures = new DailyTemperatures(new [] { 89, 62, 70, 58, 47, 47, 46, 76, 100, 70 });
dailyTemperatures.PrintExample();
#endregion
#region 747. Largest Number at Least Twice of Others
LargestNumberAtLeastTwiceOfOthers largestNumberAtLeastTwiceOfOthers = new LargestNumberAtLeastTwiceOfOthers(new [] { 3, 6, 1, 0 });
largestNumberAtLeastTwiceOfOthers.PrintExample();
#endregion
#region 771. Jewels and Stones
string j = "aA", s = "aAAbbbb";
JewelsAndStones jewelsAndStones = new JewelsAndStones(j, s);
jewelsAndStones.PrintExample();
#endregion
#region 832. Flipping an Image
int[][] flippingImageArray = new int[3][];
flippingImageArray[0] = new int[] { 1, 1, 0 };
flippingImageArray[1] = new int[] { 1, 0, 1 };
flippingImageArray[2] = new int[] { 0, 0, 0 };
FlippingAnImage flippingAnImage = new FlippingAnImage(flippingImageArray);
flippingAnImage.PrintExample();
#endregion
#region 917. Reverse Only Letters
ReverseOnlyLetters reverseOnlyLetters = new ReverseOnlyLetters("Qedo1ct-eeLg=ntse-T!");
reverseOnlyLetters.PrintExample();
#endregion
Console.ReadLine();
}
public static void Main(string[] args)
{
WordDictionary wd = new WordDictionary();
wd.AddWord("bad");
wd.AddWord("dad");
wd.AddWord("mad");
Console.Write(wd.Search("pad"));
Console.Write(wd.Search("bad"));
Console.Write(wd.Search(".ad"));
Console.Write(wd.Search("b.."));
KClosedToOrigin kC = new KClosedToOrigin();
//int[][] points = new int[2][];
//points[0] = new int[] { 1, 0 };
//points[1] = new int[] { 0, 1 };
//kC.KClosest(points, 2);
TopKWithSortedDictionary topK = new TopKWithSortedDictionary();
//topK.TopKFrequent(new int[] {1,1,1,2,2,3 }, 2);
CourseScheduling_AdjMatrix_Courses courses = new CourseScheduling_AdjMatrix_Courses();
//char[][] grid = new char[4][];
//grid[0] = new char[] {'X', 'X', 'O', 'O'}; // { '1','1','0','0', '0'};
//grid[2] = new char[] { 'X', 'O', 'O', 'X' }; // { '1', '1', '0' , '0', '0' };
//grid[3] = new char[] { 'X', 'X', 'O', 'X' }; // { '0','0','1','0','0' };
//grid[1] = new char[] { 'X', 'O', 'X', 'X' }; // { '0','0','0','1','1'};
SurroundedRegions s = new SurroundedRegions();
//s.Solve(grid);
NumberOfIslands n = new NumberOfIslands();
//var arr = new int[5, 4]
// {
// {1,1, 0, 0},
// {0,0, 1, 0},
// {0,0, 0, 0},
// {1,0, 1, 1},
// {1,1, 1, 1},
// };
//n.numberAmazonGoStores(5, 4, arr);
MinCostInAGrid minC = new MinCostInAGrid();
int[][] grid = new int[4][];
grid[0] = new int[] { 1, 1, 1, 1 };
grid[1] = new int[] { 2, 2, 2, 2 };
grid[2] = new int[] { 1, 1, 1, 1 };
grid[3] = new int[] { 2, 2, 2, 2 };
//minC.MinCost(grid);
//n.NumIslands(grid);
CriticalRoutersInANetwork rt = new CriticalRoutersInANetwork();
//List<List<int>> ls = new List<List<int>> {
// new List<int> {1,2},
// new List<int> {2,3},
// new List<int> {3,4},
// new List<int> {4,5},
// new List<int> {5,1},
//};
//rt.CriticalRouters(6,7,ls);
// courses.FindOrder(4, prerequisites);
// example ex = new example();
// int[] arr = new int[] {4,5,2,7,8 };
//Console.Write(ex.heapSort(arr, 5));
LevelOrder_BottomUp lvlOrder = new LevelOrder_BottomUp();
//TreeNode root = new TreeNode(5);
//root.left = new TreeNode(4);
//root.right = new TreeNode(8);
//root.right.left = new TreeNode(13);
//root.right.right = new TreeNode(4);
//root.left.left = new TreeNode(11);
//root.left.left.left = new TreeNode(7);
//root.left.right = new TreeNode(2);
//Solution sl = new Solution();
//sl.HasPathSum(root, 22);
// lvlOrder.LevelOrderBottom(root);
WordLadder_BFS wl = new WordLadder_BFS();
wl.LadderLength_BFS("hit", "cog", new string[] { "hot", "dot", "dog", "lot", "log", "cog" });
// WordLadder_BFS_LessEfficient wlbfs = new WordLadder_BFS_LessEfficient();
// wlbfs.FindLadders("hit","cog",new string[] { "hot", "dot", "dog", "lot", "log", "cog" });
TrieDataStructure obj = new TrieDataStructure();
// obj.InsertWord("spinclass");
//bool exists = obj.Search("spin");
// bool startsWith = obj.StartsWith("spin");
//int nodes = 3;
List <List <int> > graph = new List <List <int> >();
//graph = CreateGraph(nodes);
//AddEdge(graph, 0, 1);
//AddEdge(graph, 0, 2);
// AddEdge(graph, 1, 2);
//AddEdge(graph, 2, 3);
//AddEdge(graph, 3, 4);
//AddEdge(graph, 2, 5);
//AddEdge(graph, 5, 6);
//AddEdge(graph, 6, 7);
//AddEdge(graph, 7, 8);
//AddEdge(graph, 8, 5);
//BridgesAjacencyList bridge = new BridgesAjacencyList(graph, nodes);
//List<int> bridges = bridge.FindBridges();
// print the bridges
//for (int i = 0; i < bridges.Count/2; i++)
//{
// int node1 = bridges[2*i];
// int node2 = bridges[2 * i + 1];
// Console.WriteLine("Bridge is between node1: " + node1.ToString() + " and node2: " + node2.ToString());
//}
//ArticulationPointAdjacencyList artAdj = new ArticulationPointAdjacencyList(graph, nodes);
//bool[] isArticulationPoint = artAdj.FindArticulationPoints();
//for (int i = 0; i < nodes; i++)
//{
// if (isArticulationPoint[i])
// {
// Console.WriteLine("ArticulationPoint is at index : " + i);
// }
//}
CriticalConnectionsInANetwork cr = new CriticalConnectionsInANetwork();
//IList<IList<int>> connections = new List<IList<int>>();
//connections.Add(new List<int>() {0,1 });
//connections.Add(new List<int>() { 1, 2 });
//connections.Add(new List<int>() { 2,0 });
//connections.Add(new List<int>() { 1,3 });
//cr.CriticalConnections(4, connections);
PrimsAlgorithm prims = new PrimsAlgorithm();
//int[,] pm = new int[,] { { 0, 2, 0, 6, 0 },
// { 2, 0, 3, 8, 5 },
// { 0, 3, 0, 0, 7 },
// { 6, 8, 0, 0, 9 },
// { 0, 5, 7, 9, 0 } };
//prims.PrimsMinSpanningTree(pm, 5);
Console.ReadKey();
}
public void TestSolution(char[][] input1, int expectedResult)
{
var result = new NumberOfIslands().Resolve(input1);
Assert.AreEqual(expectedResult, result);
}
