UVa 401 - Palindromes -AC

最新推荐文章于 2024-04-29 22:18:42 发布
原创 最新推荐文章于 2024-04-29 22:18:42 发布 · 571 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文探讨了一种改进的算法，用于识别镜像字符串与回文串，并详细解释了如何优化代码减少不必要的行数。通过比较原始代码与优化后的版本，展示了在处理特定字符集时更高效的方法。

这道题看完题思路大致清晰，总体分开两个函数写，一个判断回文串，一个判断镜像串。

回文串判断好写，循环判断前半截与后半截是否一致即可。

关键在判断镜像串，一开始就也没多想，简单的判断呗~虽然知道要写好多，但也懒得细想。先判断字符串中有没有不是镜像字符的，有就直接返回0，没有再依次判断对称位置上的镜像字符是否对应，有不对应的就直接返回0，全都对应最后返回1.

虽然直接AC了，但这样写完了190行，突然感觉我好傻~
先贴出来吧~

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 10005

int pal(char str[MAX_SIZE])//palindrome
{
    int i,j,slen;
    slen=strlen(str);
    for (i=0,j=slen-1;i<slen/2;i++,j--)
        if (str[i]!=str[j])
            break;
    if (i==slen/2)
        return 1;
    return 0;
}

int mir (char str[MAX_SIZE])//mirrored
{
    int i,j,slen;
    slen=strlen(str);
    for (i=0;i<slen;i++)
    {
        switch (str[i])
        {
            case 'B':
                return 0;
            case 'C':
                return 0;
            case 'D':
                return 0;
            case 'F':
                return 0;
            case 'G':
                return 0;
            case 'K':
                return 0;
            case 'N':
                return 0;
            case 'P':
                return 0;
            case 'Q':
                return 0;
            case 'R':
                return 0;
            case '4':
                return 0;
            case '6':
                return 0;
            case '7':
                return 0;
            case '9':
                return 0;
        }

    }
    for (i=0;i<slen/2;i++)
    {
        switch(str[i])
        {
            case 'A':
                if (str[slen-i-1]=='A')
                    continue;
                else
                    return 0;
            case 'E':
                if (str[slen-i-1]=='3')
                    continue;
                else
                    return 0;
            case 'H':
                if (str[slen-i-1]=='H')
                    continue;
                else
                    return 0;
            case 'I':
                if (str[slen-i-1]=='I')
                    continue;
                else
                    return 0;
            case 'J':
                if (str[slen-i-1]=='L')
                    continue;
                else
                    return 0;
            case 'L':
                if (str[slen-i-1]=='J')
                    continue;
                else
                    return 0;
            case 'M':
                if (str[slen-i-1]=='M')
                    continue;
                else
                    return 0;
            case 'O':
                if (str[slen-i-1]=='O')
                    continue;
                else
                    return 0;
            case 'S':
                if (str[slen-i-1]=='2')
                    continue;
                else
                    return 0;
            case 'T':
                if (str[slen-i-1]=='T')
                    continue;
                else
                    return 0;
            case 'U':
                if (str[slen-i-1]=='U')
                    continue;
                else
                    return 0;
            case 'V':
                if (str[slen-i-1]=='V')
                    continue;
                else
                    return 0;
            case 'W':
                if (str[slen-i-1]=='W')
                    continue;
                else
                    return 0;
            case 'X':
                if (str[slen-i-1]=='X')
                    continue;
                else
                    return 0;
            case 'Y':
                if (str[slen-i-1]=='Y')
                    continue;
                else
                    return 0;
            case 'Z':
                if (str[slen-i-1]=='5')
                    continue;
                else
                    return 0;
            case '1':
                if (str[slen-i-1]=='1')
                    continue;
                else
                    return 0;
            case '2':
                if (str[slen-i-1]=='S')
                    continue;
                else
                    return 0;
            case '3':
                if (str[slen-i-1]=='E')
                    continue;
                else
                    return 0;
            case '5':
                if (str[slen-i-1]=='Z')
                    continue;
                else
                    return 0;
            case '8':
                if (str[slen-i-1]=='8')
                    continue;
                else
                    return 0;
        }
    }
    return 1;
}

int main()
{
    char str[MAX_SIZE];
    while (gets(str)!=NULL)
    {
        int pa,mi;
        pa=pal(str);
        mi=mir(str);
        if (pa==0&&mi==0)
            printf("%s -- is not a palindrome.\n",str);
        else if (pa==1&&mi==0)
            printf("%s -- is a regular palindrome.\n",str);
        else if (pa==0&&mi==1)
            printf("%s -- is a mirrored string.\n",str);
        else if (pa&&mi)
            printf("%s -- is a mirrored palindrome.\n",str);
        printf("\n");
    }
    return 0;
}


AC之后感觉这题这么写实在太狠了，然后又看了一下网上代码，看到

首先可以用两个数组把题目中的表格存起来

char  *ch = "AEHIJLMOSTUVWXYZ12358";
char  *re = "A3HILJMO2TUVWXY51SEZ8";

这才受到启发，把原来代码进行了改进，但这样要注意判断镜像串的时候要讨论字符串长度是否为1，否则会WA

修改后AC的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 10005

int pal(char str[MAX_SIZE])
{
    int i,j,slen;
    slen=strlen(str);
    for (i=0,j=slen-1;i<slen/2;i++,j--)
        if (str[i]!=str[j])
            break;
    if (i==slen/2)
        return 1;
    return 0;
}

int mir (char str[MAX_SIZE])
{
    char *ch="AEHIJLMOSTUVWXYZ12358";
    char *re="A3HILJMO2TUVWXY51SEZ8";
    int i,j,slen;
    slen=strlen(str);
    if (slen==1)
    {
        for (j=0;j<strlen(ch);j++)
            if (str[0]==ch[j]&&str[0]==re[j])
                return 1;
        return 0;
    }
    else
    {
        for (i=0;i<slen/2;i++)
        {
            for (j=0;j<strlen(ch);j++)
                if (str[i]==ch[j]&&str[slen-i-1]==re[j])
                {
                    j=-1;
                    break;
                }
            if (j!=-1)
                return 0;
        }
        return 1;
    }
}

int main()
{
    char str[MAX_SIZE];
    while (gets(str)!=NULL)
    {
        int pa,mi;
        pa=pal(str);
        mi=mir(str);
        if (pa==0&&mi==0)
            printf("%s -- is not a palindrome.\n",str);
        else if (pa==1&&mi==0)
            printf("%s -- is a regular palindrome.\n",str);
        else if (pa==0&&mi==1)
            printf("%s -- is a mirrored string.\n",str);
        else if (pa&&mi)
            printf("%s -- is a mirrored palindrome.\n",str);
        printf("\n");
    }
    return 0;
}


 

 

 

UVaOJ-401(Palindromes).zip_401 Palindromes
09-22
判断输入字符串是否为镜像或回文串。 来源于UVaOJ - 401. 水题。
UVa401 Palindromes 回文词 题解
weixin_51627873的博客
08-14 258
UVa401 Palindromes 回文词 题目链接：UVa401 题目描述 输入格式 输出格式 题目翻译 输入是一个字符串，判断它是否为回文串以及镜像串。输入字符串保证不含数字0 。所谓回文串，就是反转以后和原串相同，如abba和madam 。所谓镜像串，就是左右镜像之后和原串相同，如2S 和3AIAE 。注意，并不是每个字符在镜像之后都能得到一个合法字符。在本题中，每个合法字符的镜像如上表所示。 输入的每行包含一个字符串（保证只有上述字符，不含空白字符），判断它是否为回文串和镜像串（共4种组合）
UVA401 回文词 Palindromes 题解
m0_63486615的博客
01-17 374
题意翻译 输入是一个字符串，判断它是否为回文串以及镜像串。输入字符串保证不含数字00 。所谓回文串，就是反转以后和原串相同，如abbaabb**a 和madammadam 。所谓镜像串，就是左右镜像之后和原串相同，如2S2S 和3AIAE3AIA**E 。注意，并不是每个字符在镜像之后都能得到一个合法字符。在本题中，每个合法字符的镜像如下表所示： Character Reverse A A E 3 H H I I J
UVA 401
Darklovy
05-18 533
UVA 401:  输入一个字符串，判断它是否是回文串以及镜像串。输入字符串保证不含数字0.所谓回文串，就是反转以后和原串相同，如abba和madam. 所谓镜像串，就是左右镜像后与原串相同，如2S和3AIAE.注意，并不是每个字符在镜像后都能够得到一个合法字符。 #include #include #include using namespace std; const ch
UVa：401 - Palindromes
Ac_freedom
04-19 540
这是回归以后发表的第一道UVa的题目，略感
UVA 401（palindorme）简单字符串处理
阿歇的专栏
11-01 922
入门的字符串处理，小心为妙。 坑爹的注意空格输出 #include #include #include using namespace std; bool is_p(char *s,int len)//判断是否为回文注意下标 { for(int i=0;i<len/2;i++) { if(s[i]!=s[len-i-1]) ret
例题3-3 UVA401 Palindromes（20行AC代码）
努力做个书呆儿
02-04 314
紫书刷题进行中，题解系列点这里 例题3-3 UVA401 Palindromes（20行AC代码） 思路分析 判断是否为回文串和镜像串，根据二者组合输出相应提示信息。 回文串：从正反读相同，如ABCBA 镜像串：将源串S的每个字符转为相应镜像字符后得到新字符串Srev，若Srev和原串S互为回文串，则S为镜像串（注意：若某个字符的镜像字符为空，则肯定不满足条件） 可用哈希数组存储字符映...
UVA - 401-Palindromes
Never say never
12-01 856
题目链接：Palindromes UVA - 401 Palindromes Time Limit:3000MS   Memory Limit:Unknown   64bit IO Format:%lld & %llu SubmitStatus Description A regular palindrome is a
UVA401 ​​​​​​​Palindromes【字符串】
C++的星空
11-04 385
Palindromes  UVA - 401  题目传送门 题目大意：给你一个字符串，判断其是回文串还是镜像串。 AC代码： #include &lt;cstdio&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;cmath&gt; #include &lt;cstdlib&gt; #inclu...
Palindromes UVA - 401
BackToMe的博客
08-15 401
Palindromes UVA - 401 题目传送门：https://vjudge.net/problem/UVA-401（平台VJ）； 题目大意： 给你一个字符串，判断它是否是回文字符串，或者它是一个镜像字符串，或者它是什么都不是； 镜像字符串，比如J -> L , E -> 3, Z -> 5,等等，就是看起来和它相反的数字或字符 AC Code: #include #i
UVA401回文串+镜像串判断
qq_43941796的博客
07-02 359
题目链接：https://www.luogu.com.cn/problem/UVA401 回文串的判断不难，难点在于镜像串的判断，所谓镜像串就是根据题目的镜像表两次镜像后保持原样就是镜像串，第一次镜像后得到的是这个串的倒像，所以判断一个镜像串的依据就是一次翻转后是这个串的倒像。 问题在于怎么镜像，写个函数整个串镜像？还是写个函数只镜像单个字符？显然如果我们镜像整个串会麻烦很多，所以选择镜像单个字符。随之而来的问题是我们怎么存题目给的镜像表，我一开始的想法是用两个string分别存原字符和镜像字符，然后每次镜
UVA 401 回文词 Palindromes
阿巴阿巴
08-21 325
UVA 401
uva 401(简单字符处理题)
robotcator
05-04 701
1：判断回文串 2：判断镜像串
UVa 401 - Palindromes
weixin_34377065的博客
04-16 132
https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=96&page=show_problem&problem=342 题目： 1. 回文数： 一串由字母和数字组成的字符串，正着读和逆着读是相同的；例如"ABCDEDCBA"; 2. 镜像数：一串由字母...
UVa OJ 回文词(401)
知行合一
07-12 912
/******************************************* Problem:UVA OJ-401 Palindromes Date:11/07/2014 Author:Praker ********************************************/ #include #include #define maxn 10000 char str
UVAoJ --401
fgdxcw的专栏
09-18 733
UVAoJ –401 这是第一次写的代码，编写两个函数分别判断镜像和回文，然后就是两个结果的排列组合了，根据结果不同输出不同的判断，但是以下这段代码的结果却是WA。还在理解中#include <stdio.h> #include <string.h>char buf[21];int is_palindrome(char a[]) { int i,len=strlen(a); fo
UVa401 - Palindromes
weixin_62074861的博客
04-29 354
UVa401 - Palindromes：一个Bug点
UVA401(POJ1590) - Palindromes
weixin_33989058的博客
09-28 100
UVa 401 -- Palindromes题目大意：就是输入一连串字符，判断每一行的字符串输入那一种情况，有regular palindrome，mirroredpalindrome，mirrored string， not a palindrome 四种情况，大概的判断方法已经通过表格给出。解题过程：读入每一行字符串，然后从首尾开始判断，首先讨论两个字符是否相等，然后在相等与不相等的两种情况里...
uva 401
liwuqi123456的博客
01-18 396
uva 401 判断是否为回文串和镜像串，在判断是否为回文串的时候问题不大，主要是判断镜像串的时候看怎么将某个字符的镜像字符给取出来，我在这里是使用了一个将字母ascii码减去65，将数值ascii码减去49来实现的。 #include #include int palindrome(char * input); int mirror(char * input); void f
Codeforce div2 #401 E. Hanoi Factory
WA是一笔财富
02-26 398
传送门：E. Hanoi Factory 题意：给定n个空心圆柱形砖块和他们的内径外径以及高度，要把他们摞到最高并且满足上面的外径一定要小于等于下面的外径，上面的外径要大于下面的内径。 思路：赛后补的这个题，看完题后觉得是DP，看这个题的tag也有dp，但是想不出具体该怎么转移状态来，最终还是向题解妥协。很简单的一种思路是用栈去贪心的保存所用的砖块，先按外径排序，外径相等的话内径较大的在前面，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值