int main() {
countdown(10);
countdownEven(10);
printf("%s %s a palindrome\n", "MADAM", isPalindrome("MADAM", strlen("MADAM")) ? "is" : "is not");
LinkedList a = {3, NULL};
LinkedList b = {-4, &a};
LinkedList c = {2, &b};
LinkedList d = {1, &c};
printf("Sum: %d\n", sum(&d));
printf("isAllPositive: %d\n", isAllPositive(&d));
printf( isAllPositiveLessReadableButShorterWithALongerFunctionName(&d) ? "All positive!\n" : "Not all positive!\n");
printList(&d);
printf("\n");
printListReverse(&d);
printf("\n");
//1 -> 2 -> -4 -> 3 ->
//3 -> -4 -> 2 -> 1 ->
// BinTree* bt1 = NULL;
// BinTree bt = NULL; // can't assign NULL to struct
BinTree jean = {"Jean", 24, NULL, NULL};
BinTree jeane = {"Jeane", 27, NULL, NULL};
BinTree icel = {"Icel", 10, NULL, NULL};
BinTree candace = {"Candace", 48, &jean, &jeane};
BinTree lovely = {"Lovely", 9, &icel, NULL};
BinTree honey = {"Honey", 40, &lovely, NULL};
BinTree jj = {"JJ", 3, &honey, &candace};
printf("Population: %d\n", pop(&jj));
printf("Max sales: %d\n", maxSales(&jj));
printf("Num levels: %d\n", numLevels(&jj));
return 0;
}
int main ()
{
char* heapPtr;
heapPtr = malloc(64*sizeof(char));
int n;
int result;
char inputText[TEXT_LEN] = "\0";
n = -1;
while(n < LO_NUM_LIMIT || n > HI_NUM_LIMIT)
{
printf("Please enter an integer from 0 to 2000000000: ");
scanf("%d",&n);
}
char Number[TEXT_LEN];
snprintf(Number,TEXT_LEN,"%d",n);
while(strlen(inputText) < LO_STRING_LEN_LIMIT || strlen(inputText) > HI_STRING_LEN_LIMIT)
{
printf("Please enter text between 4-8 chars: ");
scanf("%s",&inputText);
}
result = isPalindrome(Number);
if(result == 1)
snprintf(heapPtr,TEXT_LEN,"%s %s %s",Number,inputText,Number);
else
snprintf(heapPtr,TEXT_LEN,"%s %s",inputText,Number);
printf("%s\n",heapPtr);
free(heapPtr);
return(EXIT_SUCCESS);
}
int main()
{
int a, x, y, max;
max = 0;
for (x = 999; x > 99; x--)
{
for (y = 999; y > 99; y--)
{
if (isPalindrome(x*y))
{
if (max < x*y)
max = x*y;
else
break;
// return 0;
}
}
}
printf("%d\n", max);
}
int main (int argc, const char * argv[]) {
int result = 0;
int potential = 0;
int x = 999;
int y = 999;
for (x = 999; x>0; x--) {
for (y = 999; y>=0; y--) {
potential = x*y;
if (isPalindrome(potential)) {
if (potential > result) {
result = potential;
}
}
}
}
printf("Result: %d\n", result);
return 0;
}
/*
Find the largest palindrome from multiples ranging from min to max.
@param min: The smallest multiple
@param max: The largest multiple
@return The largest palindrome product
*/
int largest_palindrome_product(const int min, const int max) {
int tmp;
int max_palindrome = 0;
// Loop through all possible combinations
for (int i = max; i >= min; i--) {
for (int j = i; j >= min; j--) {
// Check for palindrome product
tmp = i * j;
if (isPalindrome(tmp)) {
// Check for maximum palindrome
if (max_palindrome < tmp) max_palindrome = tmp;
}
}
}
return max_palindrome;
}
bool validWordSquare(std::vector<std::string>& W) {
int h = W.size();
int w = W[0].size();
int mindia = std::min(h, w);
//printf("%d %d %d\n", h, w, mindia);
for (int i = 0; i < w+h-1; ++i) {
int y = std::min(i, h-1);
int x = std::max(0, i-h+1);
std::string dia;
while (y >= 0 && x < w) {
dia += W[y][x];
y--;
x++;
}
//printf("%s\n", dia.c_str());
if (!isPalindrome(dia))
return false;
}
return true;
}
int main()
{
int max=0, max_palindrome=0;
for (int i=999;i;--i)
{
for (int j=999;j;--j)
{
int candidate = i*j;
int len = countDigits(candidate);
if ((isPalindrome(candidate,len)) && (len >= max) && (candidate > max_palindrome))
{
max = len;
max_palindrome = candidate;
}
}
}
std::cout << max_palindrome << std::endl;
}
int minCut(string s) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
int len = s.length();
if(len <= 1)
return 0;
int cutIndex = 0;
int endIndex = len;
int minCuts = 0;
while(cutIndex < len)
{
string sub = s.substr(cutIndex, (endIndex -cutIndex));
if(isPalindrome(sub))
{
cutIndex = endIndex;
endIndex = len;
if(cutIndex == len)
return minCuts;
minCuts++;
}
else
{
endIndex--;
}
}
return minCuts;
}
static char isTextPalindrome(const char* text){
char* tempstr = malloc((strlen(text)+1)*sizeof(char));
if(!tempstr)
return 'o';
strcpy(tempstr, text);
char* token = strtok(tempstr, "\n");
while (token) {
if(!isPalindrome(token)){
free(tempstr);
return 'f';
}
token = strtok(NULL, "\n");
}
free(tempstr);
return 't';
}
string longestPalindrome(string s) {
if (s.length() <=1 ) {
return s;
}
string ret = s.substr(0, 1); //边界条件
int strLen = s.length();
for (int i = 0; i < strLen; i++) {
for (int j = strLen - 1; j > 0; j--) { //两边向中间搜素，否则会TLE
if (isPalindrome(s, i, j)) {
ret = (j-i+1) > ret.length() ? s.substr(i,j-i+1) : ret;
break;
}
}
}
return ret;
}
int main()
{
clock_t start, end;
float time_passed;
start = clock();
int i,j, max = 0;
for(i=999; i>0; i--){
for(j=i; j>0; j--){
// if a palindrome was found
if(isPalindrome(i*j)){
if(i*j>max) max=j*i;
}
}
}
printf("\nFound a solution for %d", max);
end = clock();
time_passed = (end-start)*1.0/CLOCKS_PER_SEC;
printf("\nThe execution took me %f seconds\n", time_passed);//0.025972 seconds
return 0;
}
/* You shouldn't need to modify the main() function */
int main(void)
{
int i;
char *testStrings[N_STRINGS];
testStrings[0] = "redder";
testStrings[1] = "tacocat";
testStrings[2] = "drabasafoolaloofasabard";
testStrings[3] = "i'mnotapalindrome";
for (i = 0; i < N_STRINGS; i++) {
printf("Checking \"%s\"... ", testStrings[i]);
if (isPalindrome(testStrings[i])) {
printf ("it's a palindrome!\n");
}
else {
printf ("nope, not a palindrome.\n");
}
}
return 0;
}
int main() {
int lp=0, a = 999, b;
while(a >= 100) {
b = 999;
while (b >= a) {
if (a * b <= lp)
break;
if (isPalindrome(a * b))
lp = a * b;
b -= 1;
}
a -= 1;
}
printf("The largest palindrome made from the product of two 3-digit numbers is « %d ».\n", lp);
}
int main() {
ListNode *head = NULL, *temp = NULL;
std::vector<int> vector(1,1);
//Create the list
for (int i=vector.size()-1; i>=0; --i) {
ListNode* newNode = new ListNode(vector[i]);
newNode->next = temp;
temp = newNode;
}
head = temp;
std::cout << std::boolalpha << isPalindrome(head) << std::endl;
//Clean up the list
while (temp) {
ListNode* next = temp->next;
delete temp;
temp = next;
}
}
int main(int argc, char *argv[])
{
switch(toInt(argv[argc-1]))
{
case 1:
printf("%i\n", checkInt(argv[1]));
break;
case 2:
printf("%f\n", checkFl(argv[1]));
break;
case 3:
intParse(argv[1]);
break;
case 4:
printf("%s\n", toUpper(argv[1]));
break;
case 5:
printf("%s\n", toLower(argv[1]));
break;
case 6:
reverseString(argv[1]);
break;
case 7:
isPalindrome(argv[1]);
break;
case 8:
reverseWords(argv[1]);
break;
case 9:
subsetCheck(argv[1], argv[2]);
break;
case 10:
partialCopy(argv[1], argv[2]);
break;
default:
printf("Error: Your selection did not match any of the available.\n");
break;
}
return 0;
}
int main()
{
int i = 999;
int j = 999;
int largest = 0;
while (i > 99)
{
while (j > 99)
{
if (isPalindrome(i * j) && i * j > largest) largest = i * j;
j--;
}
j = 999;
i--;
}
printf("%d\n",largest);
return 0;
}
vector<vector<string>> partition(string s) {
vector<vector<string>> ans;
if (s.empty()) {
return ans;
}
int n = s.length();
vector<vector<bool>> isPalindrome(n, vector<bool>(n, false));
for (int len = 1; len <= n; len++) {
for (int i = 0; i+len-1 < n; i++) {
if (len <= 2) {
isPalindrome[i][i+len-1] = (s[i] == s[i+len-1]);
} else {
isPalindrome[i][i+len-1] = isPalindrome[i+1][i+len-2] && (s[i] == s[i+len-1]);
}
}
}
vector<string> current;
search(s, 0, isPalindrome, current, ans);
return ans;
}
void query(string& key, int id, multimap<trieNode*, int>& Map, vector<vector<int>>& result) {
if(key.empty()) return;
int n = (int)key.length();
trieNode* pCrawl = root;
for(int i = n - 1; i >= 0; --i) {
if(pCrawl->children.find(key[i]) == pCrawl->children.end()) {
return;
}
pCrawl = pCrawl->children[key[i]];
pair<mapIterator, mapIterator> range = Map.equal_range(pCrawl);
if(isPalindrome(key, 0, i - 1)) {
for(auto it = range.first; it != range.second; ++it) {
if(it->second != id) {
result.push_back(vector<int>{it->second, id});
}
}
}
}
string word = "";
queryUtils(id, pCrawl, word, Map, result);
}
int main()
{
int round;
scanf("%d", &round);
for(int times=0; times<round; times++) {
char s[2][12];
int now=0, next=1;
scanf("%s", s[now]);
int len=strlen(s[now]);;
reverse(s[now], len);
for(int i=0; i<len; i++)
s[now][i] -= '0';
int count=0;
do {
for(int i=0; i<len; i++) {
s[next][i] = s[now][i]+s[now][len-i-1];
}
for(int i=0; i<len-1; i++) {
if(s[next][i] >= 10) {
s[next][i+1] += s[next][i]/10;
s[next][i] %= 10;
}
}
if(s[next][len-1] >= 10) {
s[next][len] = s[next][len-1]/10;
s[next][len-1] %= 10;
len++;
}
swap(now, next);
count++;
} while(!isPalindrome(s[now], len));
printf("%d ", count);
for(int i=0; i<len; i++)
printf("%d", s[now][i]);
printf("\n");
}
return 0;
}
int main()
{
int n, base, sign;
char s[30] = {0};
scanf("%d", &n);
for (++n; ; ++n) {
sign = 0;
for (base = 2; base <= 10; ++base) {
memset(s, 0, 30);
baseConversion(s, n, base);
if (isPalindrome(s))
if (++sign >= 2)
break;
}
if (sign >= 2) {
printf("%d\n", n);
break;
}
}
return 0;
}
bool isSymmetric(TreeNode* root) {
vector<TreeNode*> nodeQueue;
vector<TreeNode*> nextLevel;
vector<TreeNode*> nodeList;
nodeQueue.push_back(root);
while(!nodeQueue.empty()){
for(int i=0;i<nodeQueue.size();i++){
nodeList.push_back(nodeQueue[i]);
if(nodeQueue[i]!=NULL){
nextLevel.push_back(nodeQueue[i]->left);
nextLevel.push_back(nodeQueue[i]->right);
}
}
if(isPalindrome(nodeList)){
nodeList.clear();
nodeQueue = nextLevel;
nextLevel.clear();
}else{
return false;
}
}
return true;
}
//f(i) means the minimum cut of s[0...j]
//f(i) = min( f(j)+1 ) if s[j+1...i] is palindrome 0<=k<i
//we need to solve the following problem: find out all palindromes, so dp was utilized
//g(i,j) means is s[i...j] is palindrome
//g(i,j) is ture when i==j or s[i]==s[j] and (i+1==j or g(i+1,j-1) )
int minCut(string s) {
int len = s.size();
if(len == 0) return 0;
vector<vector<bool> > isPalindrome(len,vector<bool>(len));
for(int i=len-1; i>=0; i--)
{
for(int j=i; j<len; j++)
isPalindrome[i][j] = i==j || s[i]==s[j] && (i==j-1 || isPalindrome[i+1][j-1]);
}
vector<int> dp(len+1, INT_MAX);
dp[0] = 0;
for(int i=0; i<len; i++)
if(isPalindrome[0][i])
dp[i+1] = 0;
for(int i=0; i<len; i++)
{
for(int j=i; j>=0; j--)
{
if(isPalindrome[j][i])
dp[i+1] = min(dp[i+1], dp[j]+1);
}
}
return dp[len];
}
int minCut(string &s, int start, int cuts, vector<int> &scuts)
{
int minCuts = INT_MAX;
if(start == s.size()) // found one
{
return cuts;
}
for(int i = start+1; i <= s.size(); i++) // 依次考虑长度为1,2,3,..的子串是否是回文串
{
if(isPalindrome(s, start, i)) // 如果是，就递归的求后面部分的所有回文分割
{
int c = 1 + cuts;
if (scuts[i] == INT_MAX) {
scuts[i] = minCut(s, i, 0, scuts);
}
c += scuts[i];
minCuts = min(minCuts, c);
}
}
return minCuts;
}
int main(int argc, char const *argv[])
{
List L1, L2;
List Head1, Head2;
Position P;
L1 = CreateList(3);
L2 = CreateReversedList(5);
PrintList(L1);
PrintList(L2);
for (P = L1; P -> next != NULL; P = P -> next);
// P -> next = NewListNode(10);
// P = P -> next;
P -> next = L2;
PrintList(L1);
// DisconnectList(L1, &Head1, &Head2);
// PrintList(Head1);
// PrintList(Head2);
printf("%d\n", isPalindrome(L1));
return 0;
}
int main()
{
isPalindrome(-2147447412);
return 0;
}
int calculateAndCheckPalindrome(int i, int j)
{
int product = i * j;
return i != j && isPalindrome(product) ? product : j > 100 ? calculateAndCheckPalindrome(i, j - 1) : 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
printf("%d\n",isPalindrome(12321));
return 0;
}
int main(){
int arr[] = {1,2,3,2,3,2,1};
ListNode *head = init_list(arr, sizeof(arr) / sizeof(int));
cout<<isPalindrome(head)<<endl;
return 0;
}
int main(int argc, char *argv[])
{
printf("%d\n", isPalindrome(argv[1]));
return(0);
}
void test_palindrome(int x) {
bool out = isPalindrome(x);
if (out) printf("%d is palindrome\n", x);
else printf("%d is not palindrome\n", x);
}
