Question

我相信这可以通过计算该字符串中每个字符的实例来实现。即使该字符串中的单个字符至少重复两次，我们也可以将该字符串声明为回文。

例如：bbcccc可以重写为bccccb或ccbbcc。 edified可以被改写为神化。

有些书提到我们应该使用哈希表。我想我们可以使用一个列表并检查字符数。

你认为逻辑是否正确？

Answer 1

是的，主要思想是计算字符串中每个字符的时间。如果字符串最多只有一个char出现奇数次而其他所有出现奇数次，那将是真的。

例如：

aabbcc =＆gt; acbbca
aabcc =＆gt; acbca
aabbb =＆gt; abbba

Answer 2

没有。您不必使用哈希映射（正如其他一些答案所示）。但是解决方案的效率将取决于您使用的算法。

这是一个只跟踪奇数字符的解决方案。如果我们得到2赔率，我们知道它不能是一个混乱的回文。我使用数组来跟踪奇数。我一遍又一遍地重复使用数组索引0直到找到奇数。然后我使用数组索引1.如果我找到2个赔率，则返回false！

javascript中没有哈希映射的解决方案：

function isScrambledPalindrome(input) {
    // TODO: Add error handling code.
    var a = input.split("").sort();
    var char, nextChar = "";
    var charCount = [ 0 ];
    var charIdx = 0;
    for ( var i = 0; i < a.length; ++i) {
        char = a[i];
        nextChar = a[i + 1] || "";
        charCount[charIdx]++;
        if (char !== nextChar) {
            if (charCount[charIdx] % 2 === 1) {
                if (charCount.length > 1) {
                    // A scrambled palindrome can only have 1 odd char count.
                    return false;
                }
                charIdx = 1;
                charCount.push(0);
            } else if (charCount[charIdx] % 2 === 0) {
                charCount[charIdx] = 0;
            }
        }
    }
    return true;
}

console.log("abc: " + isScrambledPalindrome("abc")); // false
console.log("aabbcd: " + isScrambledPalindrome("aabbcd")); // false
console.log("aabbb: " + isScrambledPalindrome("aabbb")); // true
console.log("a: " + isScrambledPalindrome("a")); // true

使用哈希映射，我找到了一种很酷的方法来只跟踪奇数字符计数并仍然确定答案。

有趣的javascript哈希映射解决方案：

function isScrambledPalindrome( input ) { 
    var chars = {}; 
    input.split("").forEach(function(char) { 
    if (chars[char]) { 
        delete chars[char] 
    } else { 
        chars[char] = "odd" } 
    }); 
    return (Object.keys(chars).length <= 1); 
}

isScrambledPalindrome("aba"); // true
isScrambledPalindrome("abba"); // true
isScrambledPalindrome("abca"); // false

Answer 3

我的代码检查它是否可以回避或可以操纵Palindrome ＃包括＃包括 #include

    //Tested on windows 64 bit arhc by using cygwin64 and GCC

    bool isPalindrome (char *text);

    int main()
    {
       char text[100]; // it could be N with defining N

       bool isPal,isPosPal = false;
       printf("Give me a string to test if it is Anagram of Palindrome\n");
       gets(text);

       isPal = isPalindrome(text);
       isPosPal = isAnagramOfPalindrome(text);
       if(isPal == false)
        {
            printf("Not a palindrome.\n");
        }
        else
        {
            printf("Palindrome.\n");
        }
       if(isPosPal == false)
        {
            printf("Not Anagram of Palindrome\n");
        }
        else
        {
            printf("Anagram of Palindrome\n");
        }

       return 0;
    }


    bool isPalindrome (char *text) {
       int begin, middle, end, length = 0;

       length = getLength(text);
       end = length - 1;
       middle = length/2;

       for (begin = 0; begin < middle; begin++)
       {
          if (text[begin] != text[end])
          {
               return false;        
          }
          end--;
       }
       if (begin == middle)
          return true;
    }

    int getLength (char *text) { 
       int length = 0;
       while (text[length] != '\0')
       length++;
       printf("length: %d\n",length);
       return length;
    }

    int isAnagramOfPalindrome (char *text) { 

        int length = getLength(text);
        int i = 0,j=0;
        bool arr[26] = {false};
        int counter = 0;
        //char string[100]="neveroddoreven";
        int a;



        for (i = 0; i < length; i++)
        {
            a = text[i];
            a = a-97;

            if(arr[a])
            {
                arr[a] = false;
            }
            else
            {
                arr[a] = true;
            }
        }

        for(j = 0; j < 27 ; j++)
        {
            if (arr[a] == true)
            {
                counter++;
            }
        }

        printf("counter: %d\n",counter);
        if(counter > 1)
        {
            return false;
        }
        else if(counter == 1)
        {
            if(length % 2 == 0)
                return false;
            else
                return true;
        }
        else if(counter == 0)
        {
            return true;
        }

    }

Answer 4

只有当最多一个字符出现奇数时，任何字符串都可以是回文。时间和所有其他字符必须发生偶数次。以下程序可用于检查回文是否可以串。

vector<int> vec(256,0); //Vector for all ASCII characters present.
for(int i=0;i<s.length();++i)
{
    vec[s[i]-'a']++;
}
int odd_count=0,flag=0;
for(int i=0;i<vec.size();++i)
{
    if(vec[i]%2!=0)
        odd_count++;
    if(odd_count>1)
    {
        flag=1;
        cout<<"Can't be palindrome"<<endl;
        break;  
    }
}
if(flag==0)
    cout<<"Yes can be palindrome"<<endl;

Answer 5

正如其他人发布的那样，我们的想法是让每个字符对偶数长度的字符串发生偶数次，对于奇数字符串字符串则出现一个字符奇数次。

书籍建议使用哈希表的原因是执行时间。从哈希映射插入/检索是O（1）操作。是的，可以使用列表，但执行时间会略慢，因为列表的排序将是O（N log N）时间。

列表实现的伪代码是：

sortedList = unsortedList.sort;

bool oddCharFound = false;

//if language does not permit nullable char then initialise 
//current char to first element, initialise count to 1 and loop from i=1
currentChar = null;
currentCharCount = 0;
for (int i=0; i <= sortedList.Length; i++) //start from first element go one past end of list
{
    if(i == sortedList.Length 
        || sortedList[i] != currentChar)
    {
        if(currentCharCount % 2 = 1)
        {
            //check if breaks rule
            if((sortedList.Length % 2 = 1 && oddCharFound)
                || oddCharFound)
            {
                return false;
            }
            else
            {
                oddCharFound = true;
            }
        }
        if(i!= sortedList.Length)
        {
            currentCharCount = 1;
            currentChar = sortedList[i];
        }

    }
    else
    {
        currentCharCount++;
    }
}
return true;

Answer 6

这是一个使用数组的简单解决方案;不需要排序

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[256] = { 0 };
    unsigned char i[] = {"aaBcBccc"};
    unsigned char *p = &i[0];
    int c = 0;
    int j;
    int flag = 0;
    while (*p != 0)
    {
        a[*p]++;
        p++;
    }
    for(j=0; j<256; j++)
    {
        if(a[j] & 1)
        {
            c++;
            if(c > 1)
            {
                flag = 1;
                break;
            }
        }
    }
    if(flag)
        printf("Nope\n");
    else
        printf("yup\n");
return 0;

}

Answer 7

假设所有输入字符都是小写字母。

#include<stdio.h>

int main(){

char *str;
char arr[27];
int j;
int a;
j = 0;
printf("Enter the string : ");
scanf("%s", str);
while (*str != '\0'){
    a = *str;
    a = a%27;

    if(arr[a] == *str){
        arr[a]=0;
        j--;
    }else{
        arr[a] = *str;
        j++;
    }
    *str++;
}
if(j==0 || j== -1 || j==1){
    printf ("\nThe string can be a palindrome\n");

}
}

Answer 8

C＃：

bool ok = s.GroupBy(c => c).Select(g => g.Count()).Where(c => c == 1).Count() < 2;

但是，此解决方案使用散列。

如何确定字符串是否可以被操作以重写为回文？

8 个答案:

javascript中没有哈希映射的解决方案：

有趣的javascript哈希映射解决方案：