public void Largest_palindrome_from_triple_digit_factors() { var actual = Palindrome.Largest(100, 999); Assert.Equal(906609, actual.Value); Assert.Equal(new[] { Tuple.Create(913, 993) }, actual.Factors); }
public void Largest_palindrome_from_four_digit_factors() { var actual = Palindrome.Largest(1000, 9999); Assert.Equal(99000099, actual.Value); Assert.Equal(new[] { Tuple.Create(9901, 9999) }, actual.Factors); }
bool IsLychrel(BigInteger i, ref int iteration) { var temp = i.ToString(); var reverseLong = GetReverseLong(temp); var l = i + reverseLong; var reverseL = l.ToString(); if (iteration > 50) { if (!PathCache.ContainsKey(i)) { PathCache.Add(i, iteration); } return(true); } if (Palindrome.IsPalindrome(reverseL)) { if (!PathCache.ContainsKey(i)) { PathCache.Add(i, iteration); } return(false); } if (PathCache.ContainsKey(i)) { iteration += PathCache[i]; return(iteration >= 50); } iteration++; return(IsLychrel(l, ref iteration)); }
public void Largest_palindrome_from_double_digit_actors() { var actual = Palindrome.Largest(10, 99); Assert.Equal(9009, actual.Value); Assert.Equal(new[] { Tuple.Create(91, 99) }, actual.Factors); }
public void LinqIsPalindromeReturnsTrueForPalindrome() { foreach (var word in palindromes) { Assert.IsTrue(Palindrome.LinqIsPalindrome(word)); } }
static void Main(string[] args) { Palindrome Palindrome = new Palindrome("never Odd, or Even."); Console.WriteLine(Palindrome.isPalindrome()); Console.ReadKey(); }
public void GetPhrase_GetPhrase_String() { string phrase = "this is a phrase"; Palindrome newPalindrome = new Palindrome(phrase, false); Assert.AreEqual(phrase, newPalindrome.GetPhrase()); }
public void Smallest_palindrome_from_four_digit_factors() { var actual = Palindrome.Smallest(1000, 9999); Assert.That(actual.Value, Is.EqualTo(1002001)); Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(1001, 1001) })); }
public IActionResult Index(Palindrome input) { if (input.Inputword == null) { input.Message = "Result"; return(View(input)); } else { string inputWord = input.Inputword.ToLower(); inputWord = inputWord.Replace(" ", ""); string revWord; char[] charArray = inputWord.ToCharArray(); Array.Reverse(charArray); revWord = new string(charArray); if (revWord == inputWord) { input.Isclear = true; input.IsPalindrome = true; input.Message = $"Success {input.Inputword} is a Palindrome!"; } else { input.Isclear = true; input.Message = $"Sorry {input.Inputword} is NOT a Palindrome!"; } return(View(input)); } }
public void PalindromeConstructor_CreatesInstanceOfPalindrome_Palindrome() { string phrase = ""; Palindrome newPalindrome = new Palindrome(phrase, false); Assert.AreEqual(typeof(Palindrome), newPalindrome.GetType()); }
static void Main(string[] args) { Palindrome pal = new Palindrome(); String val = Console.ReadLine(); pal.palindrome(val); }
public void SampleTest() { var s = File.ReadAllText(@"f:\Pactice\test.txt"); var result = Palindrome.palindromeIndex("hgygsvlfcwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcwflvsgygh"); Assert.AreEqual(44, result); }
static void Main(string[] args) { Console.WriteLine("----------------------START ALGORITHM TESTS----------------------"); SelectionSort.RunTests(); InsertionSort.RunTests(); Factorial.RunTests(); Palindrome.RunTests(); Recursion.RunTests(); MergeSort.RunTests(); QuickSort.RunTests(); BreadthFirstSearch.RunTests(); Console.WriteLine("----------------------END ALGORITHM TESTS----------------------"); Console.WriteLine("----------------------START PATTERN TESTS----------------------"); BFS.RunTests(); DFS.RunTests(); SlidingWindow.RunTests(); TwoPointers.RunTests(); FastSlowPointers.RunTests(); MergeIntervals.RunTests(); Console.WriteLine("----------------------END PATTERN TESTS----------------------"); }
public long Largest(long maxFactor) { long largestpalindromeFound = -1; for (long i1 = maxFactor - 1; i1 > 0; i1--) { if (i1 * i1 < largestpalindromeFound) { break; } for (long i2 = i1; i2 > 0; i2--) { long currentProduct = i1 * i2; if (currentProduct > largestpalindromeFound) { if (Palindrome.IsPalindrome(currentProduct)) { largestpalindromeFound = currentProduct; } } else { break; } } } return(largestpalindromeFound); }
public void Palindrome_WhenReverse_ReturnReverse() { string input = "Palindrome"; string output = Palindrome.Reverse(input); Assert.AreEqual("emordnilaP", output); }
public void Largest_palindrome_from_four_digit_factors() { var actual = Palindrome.Largest(1000, 9999); Assert.That(actual.Value, Is.EqualTo(99000099)); Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(9901, 9999) })); }
public void Palindrome_WhenChecked_ReturnInvalid() { string input = "Palindrome"; string output = Palindrome.IsPalindrome(input); Assert.AreEqual($"The word {input} is not a Palindrome", output); }
public void IsThisAPalindrome(string word, bool expected) { var palindromeInstance = new Palindrome(); var actual = palindromeInstance.IsThisAPalindrome(word); Assert.Equal(expected, actual); }
public void Palindrome_WhenDifCase_ReturnValid() { string input = "Level"; string output = Palindrome.IsPalindrome(input); Assert.AreEqual($"The word {input} is a Palindrome", output); }
public void LinqIsPalindromeReturnsFalseForNormalWords() { foreach (var word in words) { Assert.IsFalse(Palindrome.LinqIsPalindrome(word)); } }
public void Palindrome_WhenReverse_ReturnString() { string input = "Palindrome"; string output = Palindrome.Reverse(input); Assert.IsInstanceOf(typeof(string), output); }
public void TestMethod2() { Assert.IsFalse(Palindrome.IsPalindrome("Boo Hoo")); Assert.IsFalse(Palindrome.IsPalindrome("This is a test")); Assert.IsFalse(Palindrome.IsPalindrome("Racefar")); Assert.IsFalse(Palindrome.IsPalindrome("Racca")); }
public string Run() { long ans = 0; for (long i = 1; i < TEN_THOUSAND; i++) { bool isLychel = true; BigInteger b = new BigInteger(i); for (int j = 0; j < 50; j++) { b = b + BigInteger.Parse(new string(b.ToString().Reverse().ToArray())); if (Palindrome <char> .IsPalindrome(b.ToString().ToList())) { isLychel = false; break; } } if (isLychel) { ans++; } } return(ans.ToString()); }
public void Palindrome_False(string str) { var p = new Palindrome(); var result = p.Palindrome1(str); Assert.IsFalse(result); }
public void Smallest_palindrome_from_single_digit_factors() { var actual = Palindrome.Smallest(9); Assert.That(actual.Value, Is.EqualTo(1)); Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(1, 1) })); }
public void Smallest_palindrome_from_double_digit_factors() { var actual = Palindrome.Smallest(10, 99); Assert.Equal(121, actual.Value); Assert.Equal(new[] { Tuple.Create(11, 11) }, actual.Factors); }
public void Largest_palindrome_from_triple_digit_factors() { var actual = Palindrome.Largest(100, 999); Assert.That(actual.Value, Is.EqualTo(906609)); Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(913, 993) })); }
public void Largest_palindrome_from_single_digit_factors() { var actual = Palindrome.Largest(9); Assert.Equal(9, actual.Value); Assert.Equal(new [] { Tuple.Create(1, 9), Tuple.Create(3, 3) }, actual.Factors); }
public void Largest_palindrome_from_single_digit_factors() { var actual = Palindrome.Largest(9); Assert.That(actual.Value, Is.EqualTo(9)); Assert.That(actual.Factors, Is.EqualTo(new [] { Tuple.Create(1, 9), Tuple.Create(3, 3) })); }
public void Smallest_palindrome_from_four_digit_factors() { var actual = Palindrome.Smallest(1000, 9999); Assert.Equal(1002001, actual.Value); Assert.Equal(new[] { Tuple.Create(1001, 1001) }, actual.Factors); }
public static void PalindromeMain() { System.Console.Write("please enter a palindrome: "); string palindrome = System.Console.ReadLine(); Palindrome instance = new Palindrome(); if (instance.IsPalindrome(palindrome)) { System.Console.WriteLine("\"{0}\" is a palindrome.", palindrome); } else { System.Console.WriteLine("\"{0}\" is NOT a palindrome.", palindrome); } }