public void TestReserverInMtoN()
{
var r = ReverseLinkedList.ReserverInMtoN(MyLinkList.BuildListNodeFromArray(new[] { 1, 2, 3, 4, 5, 6, 7 }), 3, 6);
Assert.AreEqual(r.Next.Next.Next.Val, 6);
Assert.AreEqual(r.Next.Next.Next.Next.Next.Next.Val, 3);
}
public void ReverseListTest1()
{
ListNode head = new ListNode(1);
ListNode node2 = new ListNode(2);
ListNode node3 = new ListNode(3);
ListNode node4 = new ListNode(4);
ListNode node5 = new ListNode(5);
head.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;
ListNode expected = new ListNode(5);
ListNode node44 = new ListNode(4);
ListNode node33 = new ListNode(3);
ListNode node22 = new ListNode(2);
ListNode node11 = new ListNode(1);
expected.next = node44;
node44.next = node33;
node33.next = node22;
node22.next = node11;
ListNode result = new ReverseLinkedList().ReverseList1(head);
Assert.IsTrue(expected.IsEqual(result));
}
public void ReverseListTestCase1()
{
var list = CommonHelpers.GetLinkedListFromArray(new[] { 1, 2, 3, 4, 5 });
var output = ReverseLinkedList.ReverseList(list).ValuesToFlatList();
output.SequenceEqual(new[] { 5, 4, 3, 2, 1 }).Should().BeTrue();
}
public void TestReverseBetween()
{
ListNode head = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5, null)))));
ReverseLinkedList.ReverseBetween(head, 2, 4);
}
public void TestMethod1(int[] head, int[] expected)
{
// Arrange
ReverseLinkedList question = new ReverseLinkedList();
ListNode headNode = null;
if (head != null && head.Length > 0)
{
headNode = new ListNode(head[0]);
ListNode node = headNode;
for (int i = 1; i < head.Length; i++)
{
node.next = new ListNode(head[i]);
node = node.next;
}
}
// Act
ListNode actual = question.ReverseList(headNode);
List <int> actualList = null;
if (actual != null)
{
actualList = new List <int>();
while (actual != null)
{
actualList.Add(actual.val);
actual = actual.next;
}
}
// Assert
CollectionAssert.AreEqual(expected, actualList?.ToArray());
}
public void TestDeleteDuplicates2()
{
int[] nums = { 1, 1, 1, 2, 3 };
ListNode l1 = ListNode.CreateListNode(nums);
ReverseLinkedList.DeleteDuplicates2(l1);
}
public void ReverseListTest(int[] values, int[] expected)
{
var head = InitializeLinkedList(values);
head = new ReverseLinkedList().ReverseListOnePass(head);
AssertLinkedList(head, expected);
}
public void TestDeleteDuplicates()
{
int[] nums = { 1, 1, 2 };
ListNode head = ListNode.CreateListNode(nums);
ReverseLinkedList.DeleteDuplicates(head);
}
public void TestReverseKGroup()
{
int[] nums = { 1, 2, 3, 4, 5 };
ListNode l1 = ListNode.CreateListNode(nums);
ReverseLinkedList.ReverseKGroup(l1, 3);
}
public void TestSortList()
{
int[] nums = { 4, 2, 1, 3 };
ListNode l1 = ListNode.CreateListNode(nums);
ReverseLinkedList.SortList(l1);
}
private static void ReverseLinkedList()
{
ReverseLinkedList reverseLinkedList = new ReverseLinkedList();
Console.WriteLine("Enter a number for LinkedList");
reverseLinkedList.Main(Convert.ToInt32(Console.ReadLine()));
}
public void TestAddTwoNumbers()
{
int[] nums = { 7, 2, 4, 3 };
int[] nums2 = { 5, 6, 4 };
ListNode l1 = ListNode.CreateListNode(nums);
ListNode l2 = ListNode.CreateListNode(nums2);
ReverseLinkedList.AddTwoNumbers(l1, l2);
}
public void ReverseOneNodeList()
{
var sol = new ReverseLinkedList();
var one = sol.ReverseList(new ListNode(100));
Assert.IsNotNull(one);
Assert.AreEqual("100", one.ToString());
}
public void ReverseTwoNodeList()
{
var sol = new ReverseLinkedList();
var two = sol.ReverseList(new ListNode(100, new ListNode(999)));
Assert.IsNotNull(two);
Assert.AreEqual("999, 100", two.ToString());
}
static void RunProgram(ref bool programRunning)
{
int linkedListLength = InputHandling.ReadCollectionLength("Length of Linked List: ");
SingleLinkedList singleLinkedList = new SingleLinkedList();
int failIndex = 0;
InputHandling.ReadCollectionElements(ref singleLinkedList, linkedListLength, ref failIndex);
ReverseLinkedList.PerformReversal(ref singleLinkedList, ref linkedListLength);
OutputHandling.Question("Do you want to reverse another Linked List? Y / N");
programRunning = InputHandling.QuestionOptions();
}
public void TestCase()
{
var p = new ReverseLinkedList();
var list = new ListNode(1);
list.Next = new ListNode(2);
list.Next.Next = new ListNode(3);
list.Next.Next.Next = new ListNode(4);
list.Next.Next.Next.Next = new ListNode(5);
p.ReverseBetween(list, 3, 4);
}
public void ReverseBetweenTest()
{
ReverseLinkedList reverseLinkedList = new ReverseLinkedList();
ListNode l5 = new ListNode(5);
ListNode l4 = new ListNode(4, l5);
ListNode l3 = new ListNode(3, l4);
ListNode l2 = new ListNode(2, l3);
ListNode l1 = new ListNode(1, l2);
ListNode res = reverseLinkedList.reverseBetween(l1, 2, 4);
Assert.IsTrue(res.next.val == 4);
}
public void ReverseListTest()
{
ReverseLinkedList reverseLinkedList = new ReverseLinkedList();
ListNode l5 = new ListNode(5);
ListNode l4 = new ListNode(4, l5);
ListNode l3 = new ListNode(3, l4);
ListNode l2 = new ListNode(2, l3);
ListNode l1 = new ListNode(1, l2);
ListNode res = reverseLinkedList.ReverseList(l1);
Assert.IsTrue(res.val == 5);
}
public void ReverseThreeNodeList()
{
var sol = new ReverseLinkedList();
var list = sol.ReverseList(
new ListNode(100,
new ListNode(999,
new ListNode(-99))));
Assert.IsNotNull(list);
Assert.AreEqual("-99, 999, 100", list.ToString());
}
public void TestReverseLinkedList()
{
var r = ReverseLinkedList.Reserve(MyLinkList.BuildListNodeFromArray(new[] { 1, 2, 3, 4, 5 }));
Assert.AreEqual(r.Next.Val, 5);
Assert.AreEqual(r.Next.Next.Val, 4);
Assert.AreEqual(r.Next.Next.Next.Next.Next.Val, 1);
r = ReverseLinkedList.Reserve_Recursive(MyLinkList.BuildListNodeFromArray(new[] { 1, 2, 3, 4, 5 }));
Assert.AreEqual(r.Next.Val, 5);
Assert.AreEqual(r.Next.Next.Val, 4);
Assert.AreEqual(r.Next.Next.Next.Next.Next.Val, 1);
}
public void ReverseBetweenTest2()
{
ReverseLinkedList reverseLinkedList = new ReverseLinkedList();
ListNode l6 = new ListNode(6);
ListNode l8 = new ListNode(8, l6);
ListNode l1 = new ListNode(1, l8);
ListNode l10 = new ListNode(10, l1);
ListNode l2 = new ListNode(2, l10);
ListNode l9 = new ListNode(9, l2);
ListNode l7 = new ListNode(7, l9);
ListNode res = reverseLinkedList.reverseBetween(l7, 2, 5);
Assert.IsTrue(res.next.next.val == 10);
}
public void reverseListTest()
{
ListNode head = TestDataNode;
while (head != null)
{
Console.Write(head.val + " -> ");
head = head.next;
}
Console.WriteLine();
head = TestDataNode;
ListNode result = ReverseLinkedList.ReverseList(head);
while (result != null)
{
Console.Write(result.val + " -> ");
result = result.next;
}
}
//static void Main()
//{
// SingleLinkedList sll = new SingleLinkedList();
// sll.InsertLast(0);
// sll.InsertLast(0);
// var ispalind = IsPalindrome(sll.head);
// Console.WriteLine();
//}
//O(Log(n)) time complexity
//O(1) space
static bool IsPalindrome(SLLNode head)
{
var middle = GetMiddleNode.GetMiddleNodeLinkedList(head);
var half1 = head;
var half2 = ReverseLinkedList.Reverse(middle);
while (half1 != null && half2 != null)
{
if (half1.data != half2.data)
{
return(false);
}
half1 = half1.next;
half2 = half2.next;
}
return(true);
}
public void Given_list_When_reverse_Then_return()
{
ListNode node = new ListNode(1)
{
next = new ListNode(2)
{
next = new ListNode(3)
{
next = new ListNode(4)
}
}
};
var result = ReverseLinkedList.ReverseList(node);
Assert.AreEqual(4, result.val);
Assert.AreEqual(3, result.next.val);
Assert.AreEqual(2, result.next.next.val);
Assert.AreEqual(1, result.next.next.next.val);
}
public void TestOne()
{
Node first = new Node();
first.Value = 1;
Node second = new Node();
second.Value = 2;
Node third = new Node();
third.Value = 3;
Node fourth = new Node();
fourth.Value = 4;
first.Next = second;
second.Next = third;
third.Next = fourth;
Assert.AreEqual(2, ReverseLinkedList.Solution(first));
}
public void ReverseEmptyList()
{
var sol = new ReverseLinkedList();
Assert.IsNull(sol.ReverseList(null));
}
/// <summary>
/// interview questions for string problems
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
String[] words = { "abcde", "hello", "apple", "kite", "padle" };
foreach (string w in words)
{
Console.WriteLine(w + " : " + RandomStringProblem.isUniqueChars(w));
}
String s = "helloiloveyou";
Console.WriteLine(s + " -> " + RandomStringProblem.RemoveDuplicateCharacters(s));
Console.WriteLine(s + " -> " + RandomStringProblem.RemoveDuplicateCharacters(s.ToCharArray()));
Console.WriteLine("apple, papel : " + RandomStringProblem.anagram("apple", "papel"));
Console.WriteLine("carrot, tarroc : " + RandomStringProblem.anagram("carrot", "tarroc"));
Console.WriteLine("hello, llloh : " + RandomStringProblem.anagram("hello", "llloh"));
s = "A quick brown fox jumped over the log";
var sarr = s.ToArray();
var saar2 = s.ToArray();
RandomStringProblem.ReplaceFun(ref sarr, sarr.Length);
RandomStringProblem.ReplaceFun(ref saar2, sarr.Length);
Console.WriteLine(string.Concat(sarr));
Console.WriteLine(string.Concat(saar2));
Console.WriteLine("aabcccaa => " + RandomStringProblem.compress("aabcccaa"));
Console.WriteLine("aaaaaaab => " + RandomStringProblem.compress("aaaaaaab"));
Console.WriteLine("ababababab => " + RandomStringProblem.compress("ababababab"));
Console.WriteLine("avfffff => " + RandomStringProblem.compress("avfffff"));
FindFirstNonRepeatingChar.Test();
/// Linked List Problems
LinkedListNode head = AssortedMethods.randomLinkedList(10, 0, 3);
Console.WriteLine(head.printForward());
LinkedListProblems.deleteDups(head);
Console.WriteLine(head.printForward());
// wordbreak problems
TestWordBreak.Run();
//MedianOfMedians.TestMedianOfMedians();
LongestCommonSubsequence.Test();
SumOfMaxRunningSequence.Test();
TestRankNode.Test();
NextInorderSuccessor.Test();
CircularArrayTest.Test();
LongestPalindrome.Test();
IsomorphicStrings.Test();
FindMinAbsFrom2Arrays.Test();
ValidateIsBST.Test();
CoinPuzzle.Test();
BinarySearch.Test();
RansomNote.Test();
atoi.Test();
TrieTest.Test();
IsTreeBalanced.Test();
//TestProducerConsumer.Test();
ShuffleDeck.Test();
//QuickRankSearch.Test();
ParenthesisCombo.Test();
Permutations.Test();
Combinations.Test();
CompressString.Test();
BuildTreeFromMatrixInput.Test();
FindAllRepeatingSubstrings.Test();
PrintTreePaths.Test();
FindLowestCommonAncestor.Test();
PrintLevelsOfABinaryTree.Test();
FindPathBetween2NodesInTree.Test();
FindPathExistsInGraph.Test();
FindPathBetween2GraphNodes.Test();
// RealTimeCounterTest.Test();
DistanceBetweenWordsInASentence.Test();
SearchingForNextCharInSearch.Test();
HashMapTester.Test();
FindElementInRotatedArray.Test();
SubTrees.Test();
LongestCommonSubstring.Test();
LongestIncreasingSequenceQuestion.Test();
ConvertTreeIntoDoublyLinkedList.Test();
Count2sBetween0andN.Test();
TestSuffixTrees.Test();
TransformWordIntoOtherWord.Test();
IsNumberAPalindrome.Test();
ConvertNumberToPhrase.Test();
CountBinary1sInStream.Test();
ReverseBitsInUnsignedInt.Test();
ReverseLinkedList.Test();
DeleteDups.Test();
_3SUM.Test();
ArraySequencesThatAddUpToSum.Tests();
FindBSTNodesThatSumUpToValue.Test();
LengthOfLongestSubstringProblem.Test();
//BuildTreeFromInorderAndPreorderTraversal.Test();
ConvertTreeToDLL.Test();
FindMissingNumberInString.Test();
SortStackWithAnotherStack.Test();
QueueFrom2Stacks.Test();
Sort2Queues.Test();
ConvertRomanNumeralToInt.Test();
MergeAllLists.Test();
DivideWithoutSlash.Test();
//RegularExpression.Test();
IsNumberValid.Test();
Console.ReadKey();
}
public void TestSimplifyPath()
{
string str = "/home/a";
ReverseLinkedList.SimplifyPath(str);
}
public void TestEvalRPN()
{
string[] nums = { "4", "13", "5", "/", "+" };
ReverseLinkedList.EvalRPN(nums);
}
static void Main(string[] args)
{
SortedMatrixSearch.Run();
SparseSearch.Run();
SearchInRotatedArray.Run();
GroupAnagrams.Run();
CombinationsOfNPairsParentheses.Run();
PermutationWithDuplicates.Run();
PermutationNoDuplicates.Run();
var subsetList = new List <List <int> >();
subsetList = SubsetInSet.FindAllSubsetInSet(new List <int> {
1, 2, 3
});
ReverseLinkedList.Run();
IsUniqueString.Run();
StoneDivisionProblem.Run();
Kangaroo.Run();
AppleAndOrange.Run();
AbbreviationProblem.Run();
FibonacciModifiedProblem.Run();
RecursiveDigitSum.Run();
RangeSumOfBST.Run();
GradingStudentsProblem.Run();
// XorSequenceProblem.Run();
CounterGameProblem.Run();
MaximizingXORProblem.Run();
LonelyIntegerProblem.Run();
FlippingBitsProblem.Run();
QueueUsingTwoStacksProblem.Run();
GetNodeValue.Run();
MergeTwoSortedLinkedLists.Run();
Compare_Two_linked_lists.Run();
DeleteNodeProblem.Run();
ArrayManipulationProblem.Run();
LeftRotationProblem.Run();
HourGlass2D.Run();
SimpleTextEditorProblem.Run();
EqualStacksProblem.Run();
MaximumElementProblem.Run();
BinarySearchTreeInsertion.Run();
TopViewProblem.Run();
TimeConvertsionProblem.Run();
BinaryTreePathsProblem.Run();
IncreasingOrderSearchTree.Run();
RemoveAllAdjacentDuplicatesInStringWithKLength.Run();
RemoveAllAdjacentDuplicatesInString.Run();
CheckStraightLineProblem.Run();
HouseRobber.Run();
UniquePathsProblem.Run();
FirstUniqueCharacterInString.Run();
BinaryTreeInorderTraversal.Run();
DailyTemperaturesProblem.Run();
CountingBitsproblem.Run();
SortIntegersByTheNumberOf1BitsProblem.Run();
HammingDistanceProblem.Run();
RansomNoteProblem.Run();
ConvertBinaryNumberInLinkedListToIntegerProblem.Run();
NumberOfStepsToReduceNumberToZeroProblem.Run();
JewelsAndStones.Run();
ClimbingStairsProblem.Run();
BestTimeToBuyAndSellStock.Run();
MajorityElementProblem.Run();
MoveZeroesProblem.Run();
InvertBinaryTree.Run();
SingleNumberProblem.Run();
MaximumDepthInTrree.Run();
MergeTwoBinaryTrees.Run();
AddBinaryProblem.Run();
PlusOneProblem.Run();
LengthOfLastWordProblem.Run();
KadaneAlgorithmForMaxSubArray.Run();
KMPAlgorithm.Run();
CountAndSayProblem.Run();
SearchInsertPosition.Run();
ImplementIndexOfString.Run();
RemoveElement.Run();
RemoveDuplicatesFromSortedArray.Run();
MergeTwoSortedLists.Run();
ValidParentheses.Run();
LongestCommonPrefix.Run();
RomanToInteger.Run();
PalindromeNumber.Run();
ReverseInteger.Run();
TwoSumProblem.Run();
AddOneToNumber.Run();
MostAmountOfChange.Run();
#region BinaryTree
LeastCommonAncestor.Run();
PrintAllPaths.Run();
HasPathSum.Run();
CheckIfBinaryTreeIsBinarySearchTree.Run();
PrintAllNodesWithRangeInBinarySearchTree.Run();
UniqueTreeStructureNumber.Run();
MirrorTree.Run();
#region BitManuiplation_GetNthNumber
NumberOfStepsToReduceNumberToZeroProblem.Run();
CountNumbersOf1InBit.Run();
ReverseThebitsInInteger.Run();
PrintBitsInInteger.Run();
GetNthBit.Run();
setNthBitTo1.Run();
SetNthBitTo0.Run();
#endregion
MinimumtValueInTrree minValueInTree = new MinimumtValueInTrree();
minValueInTree.Run();
#endregion
#region Recursion
Chessboard chessboard = new Chessboard();
chessboard.Run();
RatPathToMaze ratPathToMaze = new RatPathToMaze();
ratPathToMaze.Run();
List <string> anagramList = new List <string>();
anagramList = WordAnagram.GenerateWordAnagram("abc");
Pixel[,] pixelList = new Pixel[3, 3] {
{ new Pixel(0, 0, "red"), new Pixel(0, 1, "green"), new Pixel(0, 2, "green") },
{ new Pixel(1, 0, "red"), new Pixel(1, 1, "green"), new Pixel(1, 2, "green") },
{ new Pixel(2, 0, "red"), new Pixel(2, 1, "green"), new Pixel(2, 2, "green") }
};
FillPaint.PaintFill(pixelList, 1, 2, "green", "black");
BinaryTreesAreTheSame.Run();
#endregion
#region General problems
RotateArrayByKSpaces.Run();
#region AddtwoNumbersReferencedByTheirDigits
var addRes = AddtwoNumbersReferencedByTheirDigits.AddNumbers(new int[] { 1, 2, 7 }, new int[] { 9, 4 });
#endregion
#region RunLengthEncoding
var encodedStr = RunLengthEncoding.Encode("aabbbbc");
var decodedStr = RunLengthEncoding.Decode(encodedStr);
#endregion
#region BreakDocumentIntoChunk
var chunkRes = BreakDocumentIntoChunk.Chunkify("ab:dd:ddfcct:aab:cccc", ':', 5);
#endregion
#region GameOfLife
var gameRes = GameOfLife.GetNextInteration(new int[3, 3] {
{ 1, 0, 0 }, { 0, 1, 1 }, { 1, 0, 0 }
});
#endregion .
#endregion
#region InsertionSort
InsertionSort.insertionSort(listToSort);
#endregion
#region BinarySearch
Console.WriteLine(String.Format("%s is present at index: %s", 30, BinarySearch.binarySearch(sortedArray, 30, 0, sortedArray.Length - 1)));
Console.WriteLine(String.Format("%s is present at index: %s", 4, BinarySearch.binarySearch(sortedArray, 4, 0, sortedArray.Length - 1)));
Console.WriteLine(String.Format("%s is present at index: %s", 15, BinarySearch.binarySearch(sortedArray, 15, 0, sortedArray.Length - 1)));
#endregion
#region MergeSort
MergeSort.print(listToSort);
MergeSort.mergeSort(listToSort);
#endregion
#region QuickSort
QuickSort.print(listToSort);
QuickSort.quickSort(listToSort, 0, listToSort.Length - 1);
QuickSort.print(listToSort);
#endregion
}
