public void RomanToIntTest()
{
var c = new RomanToInteger();
// example1
var target = "III";
var result = c.RomanToInt(target);
var expected = 3;
Assert.AreEqual(expected, result);
// example2
target = "IV";
result = c.RomanToInt(target);
expected = 4;
Assert.AreEqual(expected, result);
//example3
target = "IX";
result = c.RomanToInt(target);
expected = 9;
Assert.AreEqual(expected, result);
//example4
target = "LVIII";
result = c.RomanToInt(target);
expected = 58;
Assert.AreEqual(expected, result);
//example5
target = "MCMXCIV";
result = c.RomanToInt(target);
expected = 1994;
Assert.AreEqual(expected, result);
}
public void RomanToInt(string input, int expected)
{
var sut = new RomanToInteger();
var actual = sut.RomanToInt(input);
Assert.AreEqual(expected, actual);
}
public void RomanToInt_GivenRomanNumber_ReturinsEquevalentInteger(string romanNumber, int expected)
{
var rti = new RomanToInteger();
var result = rti.RomanToInt(romanNumber);
result.Should().Be(expected);
}
public void TestConvertRomanToInteger()
{
RomanToInteger rom = new RomanToInteger();
string input;
int output;
input = "III";
output = rom.ConvertRomanToInteger(input);
Assert.AreEqual(3, output);
input = "IV";
output = rom.ConvertRomanToInteger(input);
Assert.AreEqual(4, output);
input = "IX";
output = rom.ConvertRomanToInteger(input);
Assert.AreEqual(9, output);
input = "LVIII";
output = rom.ConvertRomanToInteger(input);
Assert.AreEqual(58, output);
input = "MCMXCIV";
output = rom.ConvertRomanToInteger(input);
Assert.AreEqual(1994, output);
}
public void RomanToInt_IX()
{
var srv = new RomanToInteger();
int num = srv.RomanToInt("IX");
Assert.AreEqual(9, num);
}
public void RomanToInt_MCMXCIV()
{
var srv = new RomanToInteger();
int num = srv.RomanToInt("MCMXCIV");
Assert.AreEqual(1994, num);
}
public void RomanToIntegerTest(string input, int expected)
{
var romanToInteger = new RomanToInteger();
var actual = romanToInteger.RomanToIntBetter(input);
Assert.That(actual, Is.EqualTo(expected));
}
public void RomanToInt_LVIII()
{
var srv = new RomanToInteger();
int num = srv.RomanToInt("LVIII");
Assert.AreEqual(58, num);
}
public void MCMXCIVReturnsFiftyOneHundradandNintyFour()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("MCMXCIV");
//Assert
Assert.Equal(1994, result);
}
public void RomanNumeralLReturnsFifty()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("L");
//Assert
Assert.Equal(50, result);
}
public void RomanNumeralDReturnsFiveHundrad()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("D");
//Assert
Assert.Equal(500, result);
}
public void IIIIReturnsThree()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("III");
//Assert
Assert.Equal(3, result);
}
public void RomanNumeralIReturnsOne()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("I");
//Assert
Assert.Equal(1, result);
}
public void RomanNumeralDReturnsOneThousand()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("M");
//Assert
Assert.Equal(1000, result);
}
public void RomanNumeralVReturnsFive()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("V");
//Assert
Assert.Equal(5, result);
}
public void IVReturnsFour()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("IV");
//Assert
Assert.Equal(4, result);
}
public void RomanNumeralXReturns10()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("X");
//Assert
Assert.Equal(10, result);
}
public void LVIIIReturnsFiftyEight()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("LVIII");
//Assert
Assert.Equal(58, result);
}
public void IXReturnsNine()
{
//Arrange
var romans = new RomanToInteger();
//Act
var result = romans.RomanToInt("IX");
//Assert
Assert.Equal(9, result);
}
public void Test_RomanToInteger(string input, int result)
{
// Arrange
var sut = new RomanToInteger();
// Act
int number = sut.RomanToIntegerConverter(input);
// Assert
Assert.AreEqual(number, result);
}
public void Test_IntegerToRoman(int input, string result)
{
// Arrange
var sut = new RomanToInteger();
// Act
string number = sut.IntegerToRomanConverter(input);
// Assert
Assert.AreEqual(number, result);
}
private static void RomanToIntegerTest()
{
Console.WriteLine("\nRoman To Integer question:");
RomanToInteger romanToInteger = new RomanToInteger();
string[] testStrings = new string[] { "III", "IV", "IX", "LVIII", "MCMXCIV" };
foreach (string str in testStrings)
{
Console.WriteLine("{0} -> {1}", str, romanToInteger.RomanToInt(str));
}
}
public void RomanToInt_WhenCalledWithThirdLCExample_ReturnsCorrectResult()
{
// Arrange
var expected = 1994;
var input = "MCMXCIV";
_romanToInteger = new RomanToInteger();
// Act
var result = _romanToInteger.RomanToInt(input);
// Assert
Assert.AreEqual(expected, result);
}
public void RomanToInt_WhenCalledWithSecondLCExample_ReturnsCorrectResult()
{
// Arrange
var expected = 58;
var input = "LVIII";
_romanToInteger = new RomanToInteger();
// Act
var result = _romanToInteger.RomanToInt(input);
// Assert
Assert.AreEqual(expected, result);
}
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
}
public void RomanToInteger_BigNumber_OK()
{
int answer = new RomanToInteger().RomanToInt("MCMLXXXVIII");
Assert.AreEqual(1988, answer);
}
public void RomanToInteger()
{
RomanToInteger romanToInteger = new RomanToInteger();
Assert.AreEqual(romanToInteger.RomanToInt("MDCCLXXVI"), 1776);
}
public RomanToIntegerTests()
{
_testsVerifier = new TestsVerifier();
_objUnderTest = new RomanToInteger();
}
static void Main(string[] args)
{
var fourthLargest = QuickSelect.FindKthLargest(new int[] { -10, 2, 1, 9, -6, 44, 0, 3, -17, 8 }, 4);
int[][] people = new int[][] { new int[] { 7, 0 }, new int[] { 4, 4 }, new int[] { 7, 1 },
new int[] { 5, 0 }, new int[] { 6, 1 }, new int[] { 5, 2 } };
Array.Sort(people, (a, b) => {
if (a[0] > b[0])
{
return(1);
}
else if (a[0] < b[0])
{
return(-1);
}
else
{
return(0);
}
});
var sorted = people.OrderByDescending(i => i[0]).ThenBy(i => i[1]).ToArray();
SortedList <int, int> sortedList = new SortedList <int, int>();
HashSet <int> map = new HashSet <int>();
StringBuilder sb = new StringBuilder("Hello");
for (int i = 0; i < sb.Length; i++)
{
if (sb[i] >= 65 && sb[i] <= 90)
{
sb[i] = (char)(sb[i] + 32);
}
}
int[] arrayForSort = new int[] { -10, 2, 1, 9, -6, 44, 0, 3, -17, 8 };
BubleSort.Sort(arrayForSort, false);
int[] nums2 = new int[] { 0, 1, 2, 4, 5, 6, 7, 9 };
var binRes = binarySearch(nums2, 0, nums2.Length - 1, 0);
List <int> list = new List <int>(new int[] { 1, 3, 5, 7, 9 });
var biRes = list.BinarySearch(4);
int[] nums = new int[] { 3, 0, 1 };
(new missing_number()).MissingNumber(nums);
int seed = 0;
var xor = nums.Aggregate(seed++, (x, y) => x ^ y);
xor = Enumerable.Range(1, 4).Aggregate((x, y) => x ^ y);
(new Swapping_two_integer_variables_without_an_intermediary_variable()).swapArray(nums, 0, 2);
ListNode head = new ListNode(0);
ListNode pre = head;
for (int i = 1; i < 10; i++)
{
ListNode tmp = new ListNode(i);
pre.next = tmp;
pre = pre.next;
}
var bst = (new convert_sorted_list_to_binary_search_treeV2()).SortedListToBST(head);
LeetCode.TreeNode node = new LeetCode.TreeNode(1);
LeetCode.TreeNode node1 = new LeetCode.TreeNode(2);
LeetCode.TreeNode node12 = new LeetCode.TreeNode(5);
node.left = node1;
node.right = node12;
LeetCode.TreeNode node21 = new LeetCode.TreeNode(3);
LeetCode.TreeNode node22 = new LeetCode.TreeNode(4);
node1.left = node21;
node1.right = node22;
LeetCode.TreeNode node31 = new LeetCode.TreeNode(6);
node12.right = node31;
(new flatten_binary_tree_to_linked_list()).Flatten(node);
(new construct_binary_tree_from_preorder_and_inorder_traversalV2()).BuildTree(
new int[] { 3, 9, 20, 15, 7 },
new int[] { 9, 3, 15, 20, 7 }
);
IList <IList <int> > result2 = new List <IList <int> >();
result2.Add(new int[] { 1, 2, 3 }.Concat(new int[] { 4, 5, 6 }).ToArray());
List <int[]> _matrix = new List <int[]>();
_matrix.Add(new int[] { 1, 2, 0, 4 });
_matrix.Add(new int[] { 5, 6, 7, 8 });
_matrix.Add(new int[] { 9, 10, 11, 12 });
var matrix = _matrix.ToArray();
var row1 = matrix[0];
var bol = Enumerable.Any(row1, i => i == 0);
for (int i = 0; i < 4; i++)
{
matrix[0][i] = 0;
}
//int n = 3;
//int[][] matrix = new int[n][];
//for (int i = 0; i < n; i++)
//{
// matrix[i] = new int[n];
//}
//List<int[]> positions = new List<int[]>();
//int top = 0, left = 0, count = 1;
//while (n > 0)
//{
// if (n == 1)
// {
// (positions as List<int[]>).Add(new int[] { top, left });
// break;
// }
// (positions as List<int[]>).AddRange(Enumerable.Range(left, n - 1).Select(i => new int[] { top, i }));
// (positions as List<int[]>).AddRange(Enumerable.Range(top, n - 1).Select(i => new int[] { i, (left + n - 1) }));
// (positions as List<int[]>).AddRange(Enumerable.Range(left + 1, n - 1).Reverse().Select(i => new int[] { (top + n - 1), i }));
// (positions as List<int[]>).AddRange(Enumerable.Range(top + 1, n - 1).Reverse().Select(i => new int[] { i, left }));
// top++;
// left++;
// n -= 2;
//}
//Array.ForEach(positions.ToArray(), i => {
// matrix[i[0]][i[1]] = count;
// count++;
// Console.WriteLine($"[{i[0]},{i[1]}] - {matrix[i[0]][i[1]]}");
//});
//int[][] matrix2 = new int[2][];
//IList<int[]> resti = new List<int[]>();
//int width =3, height = 3, top = 1, left = 1;
//(resti as List<int[]>).AddRange(Enumerable.Range(left, width - 1).Select(i => new int[] { top, i }).ToArray());
//(resti as List<int[]>).AddRange(Enumerable.Range(top, height - 1).Select(i => new int[] { i, (left + width - 1) }).ToArray());
//(resti as List<int[]>).AddRange(Enumerable.Range(left + 1, width - 1).Reverse().Select(i => new int[] { (top + height - 1), i }).ToArray());
//(resti as List<int[]>).AddRange(Enumerable.Range(top + 1, height - 1).Reverse().Select(i => new int[] { i, left }).ToArray());
//var qwe = resti.Select(i => matrix2[i[0]][i[1]]).ToList();
//ListNode head = new ListNode(1);
//ListNode node1 = new ListNode(4);
//ListNode node2 = new ListNode(3);
//ListNode node3 = new ListNode(2);
//ListNode node4 = new ListNode(5);
//ListNode node5 = new ListNode(2);
//head.next = node1;
//node1.next = node2;
//node2.next = node3;
//node3.next = node4;
//node4.next = node5;
//var head2 = (new partition_list()).Partition(head, 3);
var data1 = (new permutation_sequenceV2()).GetPermutation(4, 10);
int[] arr1 = new int[] { 0, 0, 3, 0, 0, 0, 0, 0, 0 };
int[] arr2 = new int[] { -1, 1, 1, 1, 2, 3 };
(new merge_sorted_array()).MergeV2(arr1, 3, arr2, 6);
var car = (new CarPlateNumber()).Generate();
int rob = (new house_robber_ii()).Rob(new int[] { 1, 2, 1, 1 });
int[] arr = Enumerable.Repeat(int.MinValue, 4).ToArray();
var perm = (new permutations()).Permute(new int[] { 1, 1, 2 });
var solutions = (new n_queens()).SolveNQueens(4);
IList <IList <string> > list2 = new List <IList <string> >();
for (int i = 0; i < 8; i++)
{
list2.Add(Enumerable.Repeat <string>(".", 8).ToList());
}
list2[0][0] = "change";
Dictionary <string, IList <int> > res3 = new Dictionary <string, IList <int> >();
var res4 = res3.Values.ToList();
var res = combination_sum.Answer(new int[] { 2, 3, 4 }, 24);
List <char[]> board = new List <char[]>();
board.Add(new char[] { '5', '3', '.', '.', '7', '.', '.', '.', '.' });
board.Add(new char[] { '6', '.', '.', '1', '9', '5', '.', '.', '.' });
board.Add(new char[] { '.', '9', '8', '.', '.', '.', '.', '6', '.' });
board.Add(new char[] { '8', '.', '.', '.', '6', '.', '.', '.', '3' });
board.Add(new char[] { '4', '.', '.', '8', '.', '3', '.', '.', '1' });
board.Add(new char[] { '7', '.', '.', '.', '2', '.', '.', '.', '6' });
board.Add(new char[] { '.', '6', '.', '.', '.', '.', '2', '8', '.' });
board.Add(new char[] { '.', '.', '.', '4', '1', '9', '.', '.', '5' });
board.Add(new char[] { '.', '.', '.', '.', '8', '.', '.', '7', '9' });
var valid = valid_sudoku.Answer(board.ToArray());
var answer = find_first_and_last_position_of_element_in_sorted_array.Answer(new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }, 9);
var ans3 = Problem3.Answer(new int[, ] {
{ 1, 3, 1, 2, 9, 4 }, { 1, 5, 1, 2, 6, 1 }, { 4, 2, 1, 2, 8, 3 }, { 6, 1, 4, 3, 1, 1 }
});
var ans32 = Problem3.ImporvedAnswer(new int[, ] {
{ 1, 3, 1, 2, 9, 4 }, { 1, 5, 1, 2, 6, 1 }, { 4, 2, 1, 2, 8, 3 }, { 6, 1, 4, 3, 1, 1 }
});
var ans = Problem2.Answer(4, 6);
var ans2 = Problem2.ImporvedAnswer(4, 6);
var answer1 = Problem1.Answer1(10);
var answer11 = Problem1.ImprovedAnswer1(10);
var answer2 = Problem1.Answer2(10);
var result = generate_parentheses.GenerateParenthesis(4);
foreach (var s in result)
{
Console.WriteLine(s);
}
//ThreeSumClosestHelper threeSumClostest = new ThreeSumClosestHelper();
//var result = threeSumClostest.ThreeSumClosest(new int[] { -1, 2, 1, 4 }, 1);
//var result = ThreeSum.Answer(new int[] { -1, 0, 1, 2, -1, -4, 3, 4, -5, 6 });
//var result = ThreeSum.Answer(new int[] { 0,0,0,0,0});
//foreach (var s in result)
//{
// Console.WriteLine(string.Join(" ", s));
//}
//var result = LetterCombinationsOfAPhoneNumber.Answer("789");
//foreach (var s in result)
//{
// Console.WriteLine(s);
//}
//var result = DfsPermutation.Make(new int[] { 1,3,6,2});
//DfsPermutationGenerator dfs = new DfsPermutationGenerator(9);
//dfs.Make();
//DfsSolution.subsets(new int[] { 1,2,3});
RomanToInteger.RomanToInt("MCMXCIV");
StringtoInteger.Answer("-91283472332");
LeetCodeTesting();
QuickSortTest();
BinaryHeapTest();
BinarySearchTreeTest();
BinarySearchTreeMirrorTest();
AVLTreeTest();
RedBlackTreeTest();
SplayTreeTest();
SegmentTreeTest_Max();
SegmentTreeTest_Min();
SegmentTreeTest_Sum();
BTreeTest();
Console.ReadLine();
}
public void RomanToInt_MultipleRomanNumerals_ReturnsExpectedInteger(string romanNumeral, int expected)
{
var romanToInteger = new RomanToInteger();
Assert.That(romanToInteger.RomanToInt(romanNumeral), Is.EqualTo(expected));
}
