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);
}
}
public bool IsLychrelNumber(BigInteger number)
{
BigInteger currentNumber = number;
for (int i = 0; i < MAX_ITERATION; i++)
{
currentNumber += ReverseNumber(currentNumber);
if (_palindrome.IsPalindrome(currentNumber.ToString()))
{
return(false);
}
}
return(true);
}
public void TestCase()
{
var p = new Palindrome();
var list = new ListNode(1);
list.Next = new ListNode(2);
list.Next.Next = new ListNode(3);
list.Next.Next.Next = new ListNode(2);
list.Next.Next.Next.Next = new ListNode(1);
Assert.True(p.IsPalindrome(list));
list = new ListNode(2);
list.Next = new ListNode(3);
list.Next.Next = new ListNode(3);
list.Next.Next.Next = new ListNode(2);
Assert.True(p.IsPalindrome(list));
list = new ListNode(1);
Assert.True(p.IsPalindrome(list));
list = new ListNode(1);
list.Next = new ListNode(2);
Assert.False(p.IsPalindrome(list));
}
public void IsPalindromeTest_True()
{
// Arrange
Palindrome p = new Palindrome();
List <int> nList = new List <int> {
1122332211,
4321234
};
// Act / Assert
foreach (int n in nList)
{
bool result = p.IsPalindrome(n);
Assert.IsTrue(result);
}
}
public void TestWords()
{
Console.WriteLine("Palindrome examples:");
string[] words = new string[] { "Madam",
"Racecar",
"Palindrome",
"",
"A",
"101" };
Assert.AreEqual(Palindrome.IsPalindrome(words[0]), true);
Assert.AreEqual(Palindrome.IsPalindrome(words[1]), true);
Assert.AreEqual(Palindrome.IsPalindrome(words[2]), false);
Assert.AreEqual(Palindrome.IsPalindrome(words[3]), false);
Assert.AreEqual(Palindrome.IsPalindrome(words[4]), true);
Assert.AreEqual(Palindrome.IsPalindrome(words[5]), true);
}
public string Run()
{
List <int> ans = new List <int>();
for (int i = 1; i < UP_TO; i++)
{
if (Palindrome <char> .IsPalindrome(i.ToString().ToCharArray().ToList()))
{
var binary = Convert.ToString(i, 2);
if (Palindrome <char> .IsPalindrome(binary.ToCharArray().ToList()))
{
ans.Add(i);
}
}
}
return(ans.Sum().ToString());
}
public override object Run(RunModes runMode, object input, bool Logging)
{
var sum = 0;
for (int i = 0; i < 1000000; i++)
{
if (Palindrome.IsPalindrome(i.ToString()))
{
if (Palindrome.IsPalindrome(ConvertToBase(i, 2)))
{
sum += i;
}
}
}
return(sum);
}
static void RunProgram(ref bool programRunning)
{
int n = InputHandling.ReadValue("Number to check if it is a palindrome or not: ");
bool isPalindrome = Palindrome.IsPalindrome(n);
if (isPalindrome)
{
OutputHandling.Message(n + " is a palindrome!", ConsoleColor.Green);
}
else
{
OutputHandling.Message(n + " is not a palindrome!", ConsoleColor.Red);
}
OutputHandling.Question("Do you want to check if another number is a palindrome? Y / N");
programRunning = InputHandling.QuestionOptions();
}
private void BtnFilter_Click(object sender, EventArgs e)
{
LstPalindrome.Items.Clear();
LstNotPalindrome.Items.Clear();
Palindrome myPalindrome = new Palindrome();
foreach (string word in LstAll.Items)
{
bool result = myPalindrome.IsPalindrome(word);
if (result)
{
LstPalindrome.Items.Add(word);
}
else
{
LstNotPalindrome.Items.Add(word);
}
}
}
internal static void Run()
{
List <long> palindromes = new List <long>();
for (int i = 999; i > 99; i--)
{
for (int j = 999; j > 99; j--)
{
long temp = i * j;
if (Palindrome.IsPalindrome(temp.ToString()))
{
palindromes.Add(temp);
}
}
}
Console.WriteLine("SOLUTION: " + palindromes.OrderByDescending(x => x).First());
}
public void TestPalindrome()
{
int[] l1 = new int[] { 0, 1, 2, 1, 0 };
int[] l2 = new int[] { 0, 1, 2, 0 };
// solution #1 traverse and clone
LinkedListNode l1List = LinkedListNode.BuildList(l1);
Assert.True(Palindrome.IsPalindrome(l1List));
LinkedListNode l2List = LinkedListNode.BuildList(l2);
Assert.False(Palindrome.IsPalindrome(l2List));
// solution #2 iterative
Assert.True(Palindrome.IsPalindromeIterative(l1List));
// solution #3 recursive
Assert.True(Palindrome.IsPalindromeRecursive(l1List));
}
static void Main()
{
Console.WriteLine("Please enter a word or number so I can check if it's a Palindrome.");
string userInput = Console.ReadLine();
Palindrome newPalindrome = new Palindrome();
newPalindrome.SetInput(userInput);
string result = newPalindrome.IsPalindrome();
Console.WriteLine(result);
Console.WriteLine("Are you finished with this program? ['Y' for yes, 'Enter' for no]");
string finishedAnswer = Console.ReadLine();
if (finishedAnswer == "Y" || finishedAnswer == "y")
{
Console.WriteLine("Goodbye.");
}
else
{
Main();
}
}
public static string Find(string str)
{
string result = string.Empty;
if (str.Length == 1)
{
return(str);
}
else
{
if (Palindrome.IsPalindrome(str))
{
return(str);
}
}
StringBuilder sb = new StringBuilder();
for (int i = str.Length; i > 0; i--)
{
string s = ReverseString.Reverse(str.Substring(i - 1));
sb.Append(s);
sb.Append(str);
if (Palindrome.IsPalindrome(sb.ToString()))
{
if (sb.Length < result.Length || result == string.Empty)
{
result = sb.ToString();
}
}
sb.Clear();
}
return(result);
}
public void IsPalindrome_IsInputNotAPalindrome_False()
{
Palindrome testPalindrome = new Palindrome();
Assert.AreEqual(false, testPalindrome.IsPalindrome("hello"));
}
public void PalindromeNumberTestMethod5()
{
bool value = Palindrome.IsPalindrome(121);
Assert.AreEqual(true, value);
}
public void PalindromeNumberTestMethod3()
{
bool value = Palindrome.IsPalindrome(-121);
Assert.AreEqual(false, value);
}
public void Is_Palindrome_With_Only_Letters_True(string value)
{
Assert.IsTrue(palindrome.IsPalindrome(value));
}
public void IsPalindrome_Racecar()
{
Assert.IsTrue(Palindrome.IsPalindrome("Racecar"));
}
public void TestIsPalindrome(long value)
{
Assert.True(Palindrome.IsPalindrome(value));
Assert.True(Palindrome.IsPalindrome(value));
Assert.True(Palindrome.IsPalindrome(value));
}
public static void Main(string[] args)
{
Console.WriteLine(Palindrome.IsPalindrome("Deleveled"));
}
public void Lowercase_words()
{
Assert.True(Palindrome.IsPalindrome("deleveled"));
Assert.True(Palindrome.IsPalindrome("kayak"));
Assert.False(Palindrome.IsPalindrome("hello"));
}
public void PalindromeTest <T>(Node <T> input, bool expected)
{
bool testResult = Palindrome.IsPalindrome(input);
Assert.Equal(expected, testResult);
}
public void IsPalindrome_20200202()
{
Assert.IsTrue(Palindrome.IsPalindrome("20200202"));
}
public void IsPalindrome_ArgumentNullException()
{
char[] text = null;
Assert.ThrowsException <ArgumentNullException>(() => Palindrome.IsPalindrome(text));
}
public void TestIsNotPalindrome(long value)
{
Assert.False(Palindrome.IsPalindrome(value));
}
public void IsPalindrome_IsInputPalindrome_True()
{
Palindrome testPalindrome = new Palindrome();
Assert.AreEqual(true, testPalindrome.IsPalindrome("hello olleh"));
}
public void Mixedcase_words()
{
Assert.True(Palindrome.IsPalindrome("Deleveled"));
Assert.True(Palindrome.IsPalindrome("KaYAk"));
}
public void IsPalindrome_IsPhraseAPalindrome_Hello()
{
Palindrome testPalindrome = new Palindrome();
Assert.AreEqual(false, testPalindrome.IsPalindrome(testPalindrome.ToPalindrome("hello"), "hello"));
}
public static void Main(string[] args)
{
//The ToString() converts your boolean to a string
Console.WriteLine(Palindrome.IsPalindrome("Deleveled").ToString());
}
public void IsPalindrome_False()
{
char[] text = { 'a', 'b', 'c', 'c', 'a' };
Assert.AreEqual(false, Palindrome.IsPalindrome(text));
}
public void IsPalindrome_dogs()
{
Assert.IsFalse(Palindrome.IsPalindrome("dogs"));
}
