设计一个日期类,要求重载其输入输出运算符,方便输入输出(输入和输出的格式为1970.09.25),并要求实现日期加和减运算(即(1)一个日期减另一个日期返回值为这两个日期之间相隔的天数;(2)一个日期减一个整数8则返回比这个日期早8天的日期;(3)一个日期加一个整数8则返回比这个日期晚8天的日期),并能比较两个日期的先后顺序,在main函数中首先要求用户输入两个日期,然后首先输出第一个日期加100天和减100天是哪一天?再输出第一个日期与第二个日期之间相隔多少天?最后将两个日期按先后次序输出。(考虑闰年,考虑月份不同)

#include<iostream>
#include<algorithm>
#include <ctime>
using namespace std;

class Date
{
private:
    int year;
    int month;
    int day;

public:
    Date()
    {
        year = 0;
        month = 0;
        day = 0;
    }

    Date(int a,int b,int c)
    {
        year = a;
        month = b;
        day = c;
    }

    ~Date()
    {

    }

    int getYear()
    {
        return this->year;
    }

    void setYear(int year)
    {
        this->year = year;
    }

    int getMonth()
    {
        return this->month;
    }

    void setMonth(int month)
    {
        this->month = month;
    }

    int getDay(int day)
    {
        return this->day;
    }

    void setDay()
    {
        this->day =day;
    }
    bool IsLeapYear(int year)
    {
        if(year % 400 || (year % 4 && year % 100))
            return true;
        return false;
    }
    int YearsOfMonth(int year, int month)
    {
        int day;
        int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        day = days[month];
        if (month == 2)
            day += IsLeapYear(year);
        return day;
    }

    Date operator+(int a)
    {
        Date b;
        b.year = this->year;
        b.month = this->month;
        b.day = this->day + a;
        while(b.day > YearsOfMonth(b.year,b.month))
        {
            if(b.month == 12)
            {
                b.month = 1;
                b.year++;
            }
            else
            {
                b.month++;
            }
            b.day = b.day - YearsOfMonth(b.year,b.month);
        }
        return b;
    }

    Date operator-(int a)
    {
        Date b;
        b.year = this->year;
        b.month = this->month;
        b.day = this->day - a;
        while(b.day <= 0)
        {
            if(b.month == 1)
            {
                b.month = 12;
                b.year--;
            }
            else
            {
                b.month--;
            }
            b.day = b.day + YearsOfMonth(b.year,b.month);
        }
        return b;
    }

    int daysOfDate(Date d)//计算一共的天数
    {
        int days=d.day;
        for(int y=1; y<d.year; y++) //计算年
            days= days + 365+IsLeapYear(d.year);
        for(int m=1; m<d.month; m++) //计算月
            days= days + YearsOfMonth(d.year,d.month);
        return days;
    }

    int operator-(Date a)
    {
        Date b;
        b.year = this->year;
        b.month = this->month;
        b.day = this->day ;
        int days1=daysOfDate(b);
        int days2=daysOfDate(a);
        return days1 - days2;
    }

    bool operator>(Date a)
    {
        Date b;
        b.year = this->year;
        b.month = this->month;
        b.day = this->day ;
        int days1=daysOfDate(b);
        int days2=daysOfDate(a);
        if(days1 >= days2)
        {
            return true;
        }
        return false;
    }

    friend    ostream& operator<<(ostream& out, const Date &a)
    {
        out<<a.year<<"."<<a.month<<"."<<a.day;
        return out;
    }


    friend    istream& operator>>(istream& in, Date &a)
    {
        in >>a.year;
        cin.get();
        in>>a.month;
        cin.get();
        in>>a.day;
        return in;
    }
};

int main()
{
    Date a;
    Date b;
    cin>>a;
    cin>>b;
    cout<<a+100<<endl;
    cout<<a-100<<endl;
    cout<<a-b<<endl;
    if(a>b)
    {
        cout<<b<<endl;
        cout<<a<<endl;
    }
    else
    {
        cout<<a<<endl;
        cout<<b<<endl;
    }
}

 

描述

米兔爸爸为了让小米兔好好锻炼身体,便给小米兔设置了一个挑战——跳格子。

要吃到自己心爱的胡萝卜,小米兔需要跳过面前一些格子。现有 N 个格子,每个格子内都写上了一个非负数,表示当前最多可以往前跳多少格,胡萝卜就放在最后一个格子上。米兔开始站在第 1 个格子,试判断米兔能不能跳到最后一个格子吃到胡萝卜呢?

输入

输入为 N 个数字 (N<10),用空格隔开,第 i个数字 si(100si<10) 表示米兔站在第 i个格子上时,最多能往前跳的格数。

输出

若米兔能跳到最后一个格子上吃到胡萝卜,输出 “true“,否则输出 “false“

输入样例

2 0 1 0 0 3 4

输出样例

false

AC代码:

#include <bits/stdc++.h>
#include<iostream>
#include<map>
using namespace std;
int main()
{
    int b;
    vector<int>a;
    bool flag = false;
    while(cin>>b)
    {
                    a.push_back(b);
        if (cin.get() == '\n')
            break;
    }
    int mitu = 0;
    while(mitu<a.size()){
        mitu = mitu + a[mitu];
        if(mitu == a.size()-1){
            flag = true;
            break;
        }
        if(a[mitu] == 0){
            break;
        }
    }
    if(flag){
        cout<<"true"<<endl;
    }
    else
    cout<<"false"<<endl;
}

 

描述

给定一个整数N,求N!的末尾有多少个0.

输入

输入为一个整数N,1 <= N <= 1000000000.

输出

输出为N!末尾0的个数

输入样例

3
60
100
1024
23456
8735373

输出样例

0
14
24
253
5861
2183837

AC代码:

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int num = 0;
    while(cin>>num)
    {
        int cnt = 0;
        for(int i = 1; i<num; i++)
        {
            int j = i;
            while(j%5  == 0)
            {
                cnt++;
                j= j/5;
            }
        }
        cout<<cnt<<endl;
    }
    return 0;
}

 

描述

给出一个数组,数组中的数字皆为正整数,除了某一个数字,其他的数字都会出现三次。 找出那个只出现一次的数。

输入

3n+1的正整数数组,使用逗号(,)分隔(n>0)

输出

单独出现的数字

输入样例

2,3,2,2
5,1,4,5,4,5,4

输出样例

3
1

AC代码:

#include <bits/stdc++.h>
#include<iostream>
#include<map>
using namespace std;
int main()
{

    map<int,int>a;
    int b;
    while(cin>>b)
    {
        a[b]++;
        if (cin.get() == '\n')
            break;
    }
    for(map<int,int>::iterator iter=a.begin();iter!=a.end();iter++){
          if(iter->second == 1){
            cout<<iter->first<<endl;
          }
	}
}

 

描述

我们知道,在逻辑表达式中广泛使用了括号,而括号都是层次化成对出现的。也就是任意左括号都应该存在一个在同一逻辑层级的右括号作为对应。 现在我们有一些仅由括号组成的字符串序列,保证每个字符为大括号”{”,”}”、中括号”[”,”]”和小括号”(”,”)”中的一种。 需要判断给定的的序列是否合法。

输入

一行仅由括号组成的字符串

输出

如果序列合法输出 1,否则输出 0

输入样例

[()]
({[])}
[()]{}

输出样例

1
0
1

小提示

栈的典型应用

AC代码:

#include <bits/stdc++.h>
#include<vector>
#include<stack>
using namespace std;

int main()
{
    string s;
    while(cin>>s)
    {
        stack<char>a;
        bool flag = false;
        for(int i = 0; i<s.length(); i++)
        {
            if(s[i]=='[' || s[i]=='(' || s[i]=='{')
            {
                a.push(s[i]);
            }
            else if(s[i]==']' )
            {
                if(!a.empty() &&a.top()=='[')
                {
                    a.pop();
                }
                else
                {
                    a.push(s[i]);
                }
            }
            else if(s[i]==')' )
            {
                if(!a.empty() &&a.top()=='(')
                {
                    a.pop();
                }
                else
                {
                    a.push(s[i]);
                }
            }
            else if(s[i]=='}' )
            {
                if(!a.empty() &&a.top()=='{')
                {
                    a.pop();
                }
                else
                {
                    a.push(s[i]);
                }
            }
        }
        if(a.empty())
        {
            cout<<"1"<<endl;
        }
        else cout<<"0"<<endl;
    }
}

 

描述

将 M 个同样的糖果放在 N 个同样的篮子里,允许有的篮子空着不放,共有多少种不同的分法? 比如,把 7 个糖果放在 3 个篮子里,共有 8 种分法(每个数表示篮子中放的糖果数,数的个数为篮子数): 1 1 5 1 2 4 1 3 3 2 2 3 2 5 0 3 4 0 6 1 0 7 0 0

注意:相同的分布,顺序不同也只算作一种分法,如 7 0 0、0 7 0 和 0 0 7 只算作一种。

输入

输入包含二个正整数 M 和 N,以(,)分开,M 表示有几个同样的糖果,N 表示有几个同样的篮子 M与N范围:1 <= M,N <= 100。

输出

输出一个正整数 K,表示有多少种分法。

输入样例

7,3

输出样例

8

AC代码:

#include <bits/stdc++.h>
#include<iostream>
#include<map>
using namespace std;

int calc(int m,int n)
{
    if(m== 0 || n==1)
    {
        return 1;
    }
    //当n=1时,所有苹果都必须放在一个盘子里,所以返回1;
    //当没有苹果可放时,定义为1种放法;
    //递归的两条路,第一条n会逐渐减少,终会到达出口n==1;
    //第二条m会逐渐减少,因为n>m时,我们会return f(m,m) 所以终会到达出口m==0.
    if(m < n)
    {
        return calc(m,m);
    }
    else
    {
        return calc(m-n,n)+calc(m,n-1);
        //所有篮子放满和有一个篮子空的情况
        //放满的时候分法和每个篮子拿去一个糖果相同
        //有一个篮子空的时候相当于和这个篮子不存在的时候的分法相同
    }
}


int main()
{
    int m = 0;
    int n = 0;
    while(cin>>m)
    {
        cin.get();
        cin>>n;
        cout<<calc(m,n)<<endl;
    }
}

 

描述

输入32位无符号整数,输出它的反向位。 例,输入4626149(以二进制表示为00000000010001101001011011100101),返回2808701440(以二进制表示为10100111011010010110001000000000)。

输入

一个无符号32位整数字符串

输出

一个无符号32位整数,为输入整数的反向位

输入样例

4626149

输出样例

2808701440

AC代码:

#include <bits/stdc++.h>
#include<vector>
#include<stack>
#include<sstream>
using namespace std;

int pow2(int a){
     int sum = 1;
     while(a--){
        sum = sum*2;
     }
     return sum;
}



int main()
{
    int number;
    while(cin>>number)
    {
        unsigned int result = 0;
        int cnt = 0;
        unsigned int mask = 1;
    mask = mask << 31;
    while(mask)
    {
        if(number & mask)
        {
            result = result + pow2(cnt) * 1;
        }
        else
        {
            result = result + pow2(cnt) * 0;
        }
        mask = mask>>1;
        cnt++;
    }
    cout<<result<<endl;
    }
}