蓝桥杯：回文日期

最新推荐文章于 2024-07-23 15:46:40 发布
最新推荐文章于 2024-07-23 15:46:40 发布
阅读量128 收藏
点赞数
文章标签： 蓝桥杯 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64116616/article/details/129344623
版权

 题目描述：

2020 年春节期间，有一个特殊的日期引起了大家的注意：2020 年 2 月 2 日。因为如果将这个日期按 “yyyymmdd” 的格式写成一个 8 位数是 20200202，恰好是一个回文数。我们称这样的日期是回文日期。

有人表示 20200202 是 “千年一遇” 的特殊日子。对此小明很不认同，因为不到 2 年之后就是下一个回文日期：20211202 即 2021 年 12 月 2 日。

也有人表示 20200202 并不仅仅是一个回文日期，还是一个 ABABBABA 型的回文日期。对此小明也不认同，因为大约 100 年后就能遇到下一个 ABABBABA 型的回文日期：21211212 即 2121 年 12 月 12 日。算不上 “千年一遇”，顶多算 “千年两遇”。

给定一个 8 位数的日期，请你计算该日期之后下一个回文日期和下一个 ABABBABA 型的回文日期各是哪一天。

输入描述
输入包含一个八位整数 NN，表示日期。

对于所有评测用例，10000101 \leq N \leq 8999123110000101≤N≤89991231，保证 NN 是一个合法日期的 8 位数表示。

输出描述
输出两行，每行 1 个八位数。第一行表示下一个回文日期，第二行表示下一个 ABABBABA 型的回文日期。

初步思路：

        首先，将问题分解为不同模块，判断回文，判断是否为ABAB型，采取暴力索搜的方式，对目标进行索搜，在搜索的同时要保证日期的合法性。即1、3、5、7、8、10、12月份为三十一天，4、 6、 9、 11月份为三十天，二月闰年29天，平年28天。月份不能超过12。因此还要加一个判断年份为闰年还是平年的函数。

判断回文：

        笔者初步思路是将日期已字符串的形式存储，方便分别判断（但后面发现，对之后的合法日期判断造成了巨大困扰）。后来发现，其实用int型存储日期更为方便。

        

bool huiwen(string str) {//判断回文
    stack<char> s;
    for (int i = 0; i < str.length(); i++) {//将字符串依次入栈（将字符串倒序）
        s.push(str[i]);
    }
    int i = 0;
    while (!s.empty()) {
        if (str[i] != s.top()) {//将栈中元素依次弹出，与原字符依次比较
            return false;//不同就返回FALSE
        }
        i++;
        s.pop();
    }
    return true;//比较完成返回TRUE
}

判断ABAB型：

        先判断是否回文，之后只需判断前四为每隔一位是否对应相等

bool ABAB(string str) {
    if (huiwen(str)) {//先判断是否回文
        for (int i = 0; i < str.length()/4; i++) {
                //判断回文后，判断ABAB型只需判断前四位两两是否相等
            if (str[i] != str[i + 2]) {
                return false;
            }
        }
        return true;
    }
    return false;
}

判断闰年/平年：

每四年一润，不是四百年的整百年不润。

bool judgey(int y) {
    if (y % 4 == 0 && y % 100 != 0) {//4年一润，百年不润，400年润
        return true;
    }
    else if (y % 400 == 0) {
        return true;
    }
    return false;
}

判断月份：

只需判断月份是否为31或30天的月份，其他的可通过反向判断。

bool judgem(int m, int* a) {
    for (int i = 0; i < 7; i++) {
        if (m == a[i]) {
            return true;
        }
    }
    return false;
}

暴力寻找：

这一函数中就体现出用字符串存储的弊端，需要把字符串类型改为整形，方便进位。因此每次改变时也要改变原字符串中的字符。造成代码量重复（其实可以封装为一个函数，只是笔者懒得改了QWQ）

在暴力寻找时要注意判断日期的合法性，因此对日时间进行判断相应月份的进位。

string find(string str,string s) {
    int y, m, d;
    string temp;
    temp = str;
    int a[] = { 1, 3, 5, 7, 8, 10, 12 };
     //将年，月，日依次提取出来，转变为整型。
    y = (str[0] - '0') * 1000+ ((str[1] - '0') * 100)+ ((str[2] - '0') * 10) + (str[3] - '0');
    m = ((str[4] - '0') * 10) + (str[5] - '0');
    d = ((str[6] - '0') * 10) + (str[7] - '0');
    while (1) {//暴力循环搜索
        if (judgem(m, a)) {//判断月份，绝定日期进制
            while (d != 32) {
                //改变日期时，改变对应原字符串中的信息
                str[6] = d / 10 + '0';
                str[7] = d % 10 + '0';
                if (judge(str, s)) {//判断初始值是否为回文年，防止在找的时初始值。
                    if (str == temp) {
                        d++;
                        continue;
                    }
                    return str;
                }
                d++;
            }
            //月份进位，进入下一月
            m++;
            d = 1;//将天数置为一号
            str[4] = m / 10 + '0';
            str[5] = m % 10 + '0';
            str[6] = '0';
            str[7] = '1';
        }
        else if (m != 2&&m<=12) {//反向判断除2月份的其他月份
            while (d != 31) {//过程同上，就是可以封装为一个函数
                str[6] = d / 10 + '0';
                str[7] = d % 10 + '0';
                if (judge(str, s)) {
                    if (str == temp) {
                        d++;
                        continue;
                    }
                    return str;
                }
                d++;
            }
            m++;
            d = 1;
            str[4] = m / 10 + '0';
            str[5] = m % 10 + '0';
            str[6] = '0';
            str[7] = '1';
        }
        else if (m == 2) {//二月份，判断是否为闰年还是平年
            if (judgey(y)) {//闰年情况
                while (d != 30) {
                    str[6] = d / 10 + '0';
                    str[7] = d % 10 + '0';
                    if (judge(str, s)) {
                        if (str == temp) {
                            d++;
                            continue;
                        }
                        return str;
                    }
                    d++;
                }
                m++;//进位过程同上
                d = 1;
                str[4] = m / 10 + '0';
                str[5] = m % 10 + '0';
                str[6] = '0';
                str[7] = '1';
            }
            else {
                while (d != 29) {//平年情况
                    str[6] = d / 10 + '0';
                    str[7] = d % 10 + '0';
                    if (judge(str, s)) {
                        if (str == temp) {
                            d++;
                            continue;
                        }
                        return str;
                    }
                    d++;
                }
                m++;
                d = 1;
                str[4] = m / 10 + '0';
                str[5] = m % 10 + '0';
                str[6] = '0'; str[7] = '1';
            }
        }//当月份大于12时进行年份进位
        else {//将月份和日期均置一
            m = 1;
            d = 1;
            y++;
            str[0] = y / 1000 + '0';
            str[1] = (y / 100) % 10 + '0';
            str[2] = (y / 10) % 10 + '0';
            str[3] = y % 10 + '0';
            str[4] = str[6] =  '0';
            str[5] = str[7] = '1';
            if (judge(str, s)) {
                if (str == temp) {
                    d++;
                    continue;
                }
                return str;
            }
        }
    }
    
    return str;
}

判断寻找类型：

         由于题目要求寻找两个类型，因此需要一个判断函数，来调用不同的判断函数

bool judge(string str, string s) {
    if (s == "huiwen") {
        return huiwen(str);
    }
    else {
        return ABAB(str);
    }
}

主函数：

将要寻找的类型和初始日期字符串作为参数，传入find（）函数中。

int main()
{
    string s;
    cin >> s;
    string temp;
    temp=s;//防止寻找到的回文日期同时也为ABAB型，导致被find（）函数滤过。
    s=find(s, "huiwen");//第二个字符串参数，判断不同类型调用不同函数
    cout << s << '\n';
    s = find(temp, "ABAB");
    cout << s;
    return 0;
}

全部代码：

代码过于冗长（QWQ）

#include <iostream>
#include<string>
#include<stack>
using namespace std;
bool huiwen(string str) {//判断回文
    stack<char> s;
    for (int i = 0; i < str.length(); i++) {//将字符串依次入栈（将字符串倒序）
        s.push(str[i]);
    }
    int i = 0;
    while (!s.empty()) {
        if (str[i] != s.top()) {//将栈中元素依次弹出，与原字符依次比较
            return false;//不同就返回FALSE
        }
        i++;
        s.pop();
    }
    return true;//比较完成返回TRUE
}
bool ABAB(string str) {
    if (huiwen(str)) {//先判断是否回文
        for (int i = 0; i < str.length()/4; i++) {
                //判断回文后，判断ABAB型只需判断前四位两两是否相等
            if (str[i] != str[i + 2]) {
                return false;
            }
        }
        return true;
    }
    return false;
}
bool judge(string str, string s) {
    if (s == "huiwen") {
        return huiwen(str);
    }
    else {
        return ABAB(str);
    }
}
bool judgey(int y) {
    if (y % 4 == 0 && y % 100 != 0) {//4年一润，百年不润，400年润
        return true;
    }
    else if (y % 400 == 0) {
        return true;
    }
    return false;
}
bool judgem(int m, int* a) {
    for (int i = 0; i < 7; i++) {
        if (m == a[i]) {
            return true;
        }
    }
    return false;
}
string find(string str,string s) {
    int y, m, d;
    string temp;
    temp = str;
    int a[] = { 1, 3, 5, 7, 8, 10, 12 };
     //将年，月，日依次提取出来，转变为整型。
    y = (str[0] - '0') * 1000+ ((str[1] - '0') * 100)+ ((str[2] - '0') * 10) + (str[3] - '0');
    m = ((str[4] - '0') * 10) + (str[5] - '0');
    d = ((str[6] - '0') * 10) + (str[7] - '0');
    while (1) {//暴力循环搜索
        if (judgem(m, a)) {//判断月份，绝定日期进制
            while (d != 32) {
                //改变日期时，改变对应原字符串中的信息
                str[6] = d / 10 + '0';
                str[7] = d % 10 + '0';
                if (judge(str, s)) {//判断初始值是否为回文年，防止在找的时初始值。
                    if (str == temp) {
                        d++;
                        continue;
                    }
                    return str;
                }
                d++;
            }
            //月份进位，进入下一月
            m++;
            d = 1;//将天数置为一号
            str[4] = m / 10 + '0';
            str[5] = m % 10 + '0';
            str[6] = '0';
            str[7] = '1';
        }
        else if (m != 2&&m<=12) {//反向判断除2月份的其他月份
            while (d != 31) {//过程同上，就是可以封装为一个函数
                str[6] = d / 10 + '0';
                str[7] = d % 10 + '0';
                if (judge(str, s)) {
                    if (str == temp) {
                        d++;
                        continue;
                    }
                    return str;
                }
                d++;
            }
            m++;
            d = 1;
            str[4] = m / 10 + '0';
            str[5] = m % 10 + '0';
            str[6] = '0';
            str[7] = '1';
        }
        else if (m == 2) {//二月份，判断是否为闰年还是平年
            if (judgey(y)) {//闰年情况
                while (d != 30) {
                    str[6] = d / 10 + '0';
                    str[7] = d % 10 + '0';
                    if (judge(str, s)) {
                        if (str == temp) {
                            d++;
                            continue;
                        }
                        return str;
                    }
                    d++;
                }
                m++;//进位过程同上
                d = 1;
                str[4] = m / 10 + '0';
                str[5] = m % 10 + '0';
                str[6] = '0';
                str[7] = '1';
            }
            else {
                while (d != 29) {//平年情况
                    str[6] = d / 10 + '0';
                    str[7] = d % 10 + '0';
                    if (judge(str, s)) {
                        if (str == temp) {
                            d++;
                            continue;
                        }
                        return str;
                    }
                    d++;
                }
                m++;
                d = 1;
                str[4] = m / 10 + '0';
                str[5] = m % 10 + '0';
                str[6] = '0'; str[7] = '1';
            }
        }//当月份大于12时进行年份进位
        else {//将月份和日期均置一
            m = 1;
            d = 1;
            y++;
            str[0] = y / 1000 + '0';
            str[1] = (y / 100) % 10 + '0';
            str[2] = (y / 10) % 10 + '0';
            str[3] = y % 10 + '0';
            str[4] = str[6] =  '0';
            str[5] = str[7] = '1';
            if (judge(str, s)) {
                if (str == temp) {
                    d++;
                    continue;
                }
                return str;
            }
        }
    }
    
    return str;
}
int main()
{
    string s;
    cin >> s;
    string temp;
    temp=s;//防止寻找到的回文日期同时也为ABAB型，导致被find（）函数滤过。
    s=find(s, "huiwen");//第二个字符串参数，判断不同类型调用不同函数
    cout << s << '\n';
    s = find(temp, "ABAB");
    cout << s;
    return 0;
}

第一次发，没什么经验@~@（而且还发了一堆冗长的代码QWQ），望各位包容。

代码神偷阿飞12138
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
蓝桥杯：回文日期（超详细） Python
m0_52660785的博客
04-06 1046
题目： 2020 年春节期间，有一个特殊的日期引起了大家的注意：2020 年 2 月 2 日。因为如果将这个日期按 “yyyymmdd” 的格式写成一个 8 位数是 20200202，恰好是一个回文数。我们称这样的日期是回文日期。 有人表示 20200202 是 “千年一遇” 的特殊日子。对此小明很不认同，因为不到 2 年之后就是下一个回文日期：20211202 即 2021 年 12 月 2 日。 也有人表示 20200202 并不仅仅是一个回文日期，还是一个 ABABBABA 型的回文日期。对此小
1155：回文三位数.cpp
05-13
1155：回文三位数 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 13662 通过数: 8867 【题目描述】 如果一个数从左边读和从右边读都是同一个数，就称为回文数。例如6886就是一个回文数，求出所有的既是回文数又是...
蓝桥杯：回文日期C语言题解（详细）
m0_72909732的博客
05-18 331
【代码】蓝桥杯：回文日期C语言题解（详细）
蓝桥杯-回文日期(两种写法)
小程xy的博客
05-13 664
在日常生活中，通过年、月、日这三个要素可以表示出一个唯一确定的日期。牛牛习惯用 8 位数字表示一个日期，其中，前 4 位代表年份，接下来 2 位代表月份，最后 2 位代表日期。显然：一个日期只有一种表示方法，而两个不同的日期的表示方法不会相同。牛牛认为，一个日期是回文的，当且仅当表示这个日期的 8 位数字是回文的。现在，牛牛想知道：在他指定的两个日期之间（包含这两个日期本身），有多少个真实存在的日期是回文的。一个 8 位数字是回文的，当且仅当对于所有的 i。
蓝桥杯_回文日期（C语言解法）
qq_60682673的博客
09-08 814
后序使用if语句在条件中调用此函数，同时，特别注意该函数的返回值，若返回值为1，表示该日期是合法的，接着判断其是否为回文型的日期和ABABBABA型的日期；分别定义整型变量y、m、d及整型数组a[13],该数组的下标从1~12，用来分别存放对应月份的天数，变量y、m、d分别表示从输入的N后开始的日期中提取的年、月、日；通过计算方式得到y、m、d相对应的值，进一步判断得到的y、m、d是否在合法日期对于年月日的规定范围内，这一步判断可以通过编写一个函数来实现；1、输入一个八位整数N的格式为yyyymmdd型。
蓝桥杯：回文日期问题
yuukiiiwow的博客
11-30 182
蓝桥杯回文日期问题
【做题笔记】蓝桥杯Python：回文日期
未来就在脚下。
01-08 386
完整流程及思路、获取的教训、涉及的知识点
蓝桥杯训练：回文日期（#C语言）
weixin_47942464的博客
02-23 1782
题目描述 2020 年春节期间，有一个特殊的日期引起了大家的注意：2020 年 2 月 2 日。因为如果将这个日期按 “yyyymmdd” 的格式写成一个 8 位数是 20200202，恰好是一个回文数。我们称这样的日期是回文日期。 有人表示 20200202 是 “千年一遇” 的特殊日子。对此小明很不认同，因为不到 2 年之后就是下一个回文日期：20211202 即 2021 年 12 月 2 日。 也有人表示 20200202 并不仅仅是一个回文日期，还是一个 ABABBABA 型的回文日期。对此
蓝桥杯：回文日期（超详解）
weixin_61642087的博客
01-26 8371
题目：2020年春节期间，有一个特殊的日期引起了大家的注意：2020年2月2日。因为如果将这个R期按“ymmdd”沿格式写成一一个8位数是20200202恰好是一个回文数。我们称这样沿旧期是回文日期。 有人表示20200202是“千年一遇”的特殊日子。对此小明很不认同，因为不到2年之后就是下一个回文日期：202112D2即2021年12月2日。 也有人表示20200202并不仅仅是一个回文日期，还是一个ABABBABA型的回文日期。对此小明也不认同，因为大约100年后就能遇到下一个ABABBAB...
蓝桥杯真题：回文日期
weixin_54500974的博客
02-22 1190
题目描述 2020 年春节期间，有一个特殊的日期引起了大家的注意：2020 年 2 月 2 日。因为如果将这个日期按 “yyyymmdd” 的格式写成一个 8 位数是 20200202，恰好是一个回文数。我们称这样的日期是回文日期。 有人表示 20200202 是 “千年一遇” 的特殊日子。对此小明很不认同，因为不到 2 年之后就是下一个回文日期：20211202 即 2021 年 12 月 2 日。 也有人表示 20200202 并不仅仅是一个回文日期，还是一个 ABABBABA 型的回文日期。对此小
【蓝桥杯】回文日期（c语言解决）
qq_74035288的博客
03-11 643
一个 8 位数字是回文的，当且仅当对于所有的 i(1≤i≤8) 从左向右数的第i个数字和第 9−i 个数字（即从右向左数的第 i 个数字）是相同的。牛牛习惯用 8 位数字表示一个日期，其中，前 4 位代表年份，接下来 2 位代表月份，最后 2 位代表日期。现在，牛牛想知道：在他指定的两个日期之间（包含这两个日期本身），有多少个真实存在的日期是回文的。输出共一行，包含一个整数，表示在date1和date2之间，有多少个日期是回文的。牛牛认为，一个日期是回文的，当且仅当表示这个日期的8位数字是回文的。
js代码-项目实战：回文检查器
07-16
在JavaScript编程领域，"回文检查器"是一个常见的练习项目，它旨在检测一个字符串是否为回文。回文是指正读反读都能读通的词语，例如“上海自来水来自海上”或“level”。在这个项目实战中，我们将深入探讨如何利用...
蓝桥杯-回文数c实现.c
01-26
蓝桥杯回文数c实现代码，供大家参考
palindrome:回文
03-17
回文是一种特殊的字符串或序列，其特点是正读和反读完全相同。在中文中，回文不仅限于单个词语，还可以是句子、短语甚至整段文章，只要从前往后读和从后往前读都一样，就被称为回文。在计算机科学中，回文现象在很多...
TacoCat：回文
02-12
以下是一个简单的JavaScript函数示例，用于检测一个字符串是否为回文： ```javascript function isPalindrome(str) { // 将字符串转换为小写并移除非字母数字字符 str = str.toLowerCase().replace(/[\W_]/g, '')...
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1170
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
#职场发展#其他
2401_82818414的博客
05-28 1575
首先，一闪论文提供了丰富的模板和格式选择，用户可以根据自己的需求和要求轻松定制论文的格式，避免因排版问题而浪费时间。最重要的是，一闪论文还具有强大的查重降重功能，能够自动检测文本的重复率，帮助用户排除抄袭内容，确保文章的原创性。一闪论文是目前市场上一款非常靠谱的论文写作工具，不仅可以帮助用户快速完成论文撰写，还能对文章进行查重降重，确保内容原创性。综上所述，一闪论文是一个非常靠谱、实用、方便的写作工具，不仅能帮助用户快速完成论文撰写，还能确保文章的原创性，是值得推荐的一款软件。
pi_heif-0.17.0-pp310-pypy310_pp73-macosx_12_0_x86_64.whl
最新发布
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
蓝桥杯python回文日期
12-28
以下是一个用Python实现蓝桥杯回文日期的例子： ```python import datetime def is_palindrome(date): date_str = str(date).replace("-", "") return date_str == date_str[::-1] def find_palindrome_date(): date = datetime.date(2000, 1, 1) while True: date += datetime.timedelta(days=1) if is_palindrome(date): print(date) break find_palindrome_date() ``` 这段代码首先定义了一个`is_palindrome`函数，用于判断一个日期是否是回文日期。然后定义了一个`find_palindrome_date`函数，用于找到第一个回文日期并打印出来。在`find_palindrome_date`函数中，我们从2000年1月1日开始逐天增加日期，然后调用`is_palindrome`函数判断日期是否是回文日期，如果是则打印出来并结束循环。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值