CCCC-exercise

CCCC-exercise

1.L1

总结L1 1-27里面我觉得有东西可以总结的题目

贴了部分的代码

L1-006（20）

一个正整数 N 的因子中可能存在若干连续的数字。例如 630 可以分解为 3×5×6×7，其中 5、6、7 就是 3 个连续的数字。给定任一正整数 N，要求编写程序求出最长连续因子的个数，并输出最小的连续因子序列。

输入格式：

输入在一行中给出一个正整数 N（1<N<231）。

输出格式：

首先在第 1 行输出最长连续因子的个数；然后在第 2 行中按 因子1*因子2*……*因子k 的格式输出最小的连续因子序列，其中因子按递增顺序输出，1 不算在内。

输入样例：

630

输出样例：

3
5*6*7

总结

由于本题所需要寻找的是连续的因子，因此我认为不需要连续除去循环中的相同因子，而只需从因子起点开始寻找连续因子串，而>sqrt(n)的因子最多只出现一遍，因此，可以通过这个优化算法，因此以>sqrt(n)的因子开始的序列最长为1

质数需要特判：因为起始因子大于sqrt(n)而未进入循环的素数与进入循环的的素数结果需要一致，把maxx初始化为0可以解决这样的问题。

共有三数组，tsz表示里层循环中临时的连续序列，而ans是最小的最长连续序列，yz是当前里层循环的所有因子

非素数每次统计从当前i开始的连续因子最长序列，由于循环条件，保证当前因数之积是不大于t的

#include <bits/stdc++.h>
#define MAXN (int)1e7 + 5
using namespace std;
int n, maxx = 0, tsz[MAXN], ans[MAXN], yz[MAXN];
int main()
{
    cin >> n;
    for (int i = 2; i <= n/i; i++)
    {
        int t = n, countn = 0, s = 0;
             if (n % i == 0)
        for (int j = i; j <= t; j++)
        {
            if (t % j == 0)
            {
                yz[++countn] = j;
                // cout << yz[countn] << endl;
                if ((j - yz[countn - 1] == 1) || (s == 0))
                    tsz[++s] = j;
                else
                {
                    if (s > maxx)
                    {
                        for (int z = 1; z <= s; z++)
                        {
                            ans[z] = tsz[z];
                        }
                        maxx = s;
                    }
                    s = 0;
                    tsz[++s] = j;
                }
                t /= j;
            }
        }

        if (s > maxx)
        {
            for (int j = 1; j <= s; j++)
            {
                ans[j] = tsz[j];
            }
            maxx = s;
        }
    }

 if(maxx)
    cout << maxx << endl;
 else {
     cout<<1<<endl;
     cout<<n<<endl;
 }
    for (int i = 1; i <= maxx; i++)
    {
        if (i != 1)
            cout << '*';
        cout << ans[i];
    }

    return 0;
}

L1-002 打印沙漏 (20 分)

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印

*****
 ***
  *
 ***
*****

所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。

给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。

输入格式:

输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。

输出格式:

首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。

输入样例:

19 *

结尾无空行

输出样例:

*****
 ***
  *
 ***
*****
2

课后习题的加强版，其实不是很好过

由于需要输出多余的字符量，因此不能边打印边计算，需要先计算出能打印出的最大的沙漏字符数量

1.一种做法是套等差数列和公式，特判一个字符的情况，求n最大能输出的沙漏，但是我不想算

2.于是每次从一个字符往上每次增加两个 (i+=2)，每次添加上下两层的增加的数量(s+=i*2),直到s>=n

若s>n则删除多余的两层（ s -= i * 2）,并把i-=2；

*****
 *** <--从这往上为上层
  *
 *** <--从这往下为下层
*****

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    char c;
    cin >> n >> c;
    int i = 1, s = 1;
    while (s < n)
    {
        i += 2;
        s += i * 2;
    }
    if (s != n)
    {
        s -= i * 2;
        i -= 2;
    }
    int rest = n - s, max = i, space = 0;
    while (i >= 1)
    {
        for (int j = 1; j <= space; j++)
        {
            cout << ' ';
        }
        for (int j = 1; j <= i; j++)
        {
            cout << c;
        }
        cout << endl;
        space++;
        i -= 2;
    }
    i = 3;
    space--;
    while (i <= max)
    {
        space--;
        for (int j = 1; j <= space; j++)
            cout << ' ';
        for (int j = 1; j <= i; j++)
            cout << c;
        cout << endl;
        i += 2;
    }
    cout << rest << endl;
    //  << n << endl
    //  << s << endl;
    return 0;
}

L1005 （15）

把座位号存为longlong，数据范围是易错点，数组结构体存储，下标是试机号

L1007

易错点是容易遗漏对应的数字和break

L1008

易错点是输出格式要靠右对齐，且需要特判输出数字总数为5的倍数的情况下，最后一行达到5的倍数时循环内不用输出回车否则会输出两次

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int a, b, sum = 0, countn = 0;
    cin >> a >> b;
    for (int i = a; i <= b; i++)
    {
        countn++;
        printf("%5d", i);
        if (countn % 5 == 0 && i != b)
            printf("\n");
        sum += i;
    }
    printf("\n");
    printf("Sum = %d", sum);

    return 0;
}

L1009

模拟+多重特判细节题

模拟：模拟计算分式，每次求分母的最小公倍数并变成它，并将其分子也乘以相应的倍数，分子每次加上处理后的数据

细节：1.输出的假分数，整数部分和分数部分都有可能为0，于是不输出，所以在输出前要判断

其中一个为0则不输出它，两个都为0，就输出0后结束程序

2.中间空格的输出也是取决之前是否输出了整数部分，需要用一个变量保存整数部分的是否输出情况

3.若有分数 ‘/ ’符号是否输出，取决于分母是否为1，需要特判

4.分数需要化简，于是分子分母同时除以最大公约数

L1011

类似BF算法，对A中每个字符遍历B字符串，若有与B中一致的字符则删去

本题我采用了string，以及用它的迭代器去删除字符，若进行删除操作，迭代器会自动更新，

细节：1.此时需要特判是否删除来决定是否在循环中更新迭代器

2.由于字符串里面可能存在空格，所以应该使用getline(cin，s)的语句来读入字符串

L1016

本题的易错点在于，每个位置权重在数组里面的下标和与相同位置字符的下标的需要对应，Z与校验码M也要对应，其次要知道加权是*权值然后加到sum里面，不是加权平均数

本题和L1027有点类似都是下标的对应

L1027

以字符串读入，遍历每个字符，计数，若非0则存在，然后以从大到小排列，将新的下标记录到以数字下标的数组中，再次遍历字符串，将读出的该数字在arr数组中的位置存到新数组index里

L1-017

细节：1.若是负数需要将‘-’剔除

2.使用浮点数计算若用整数可能出错

3.输出的时候%应打两次

L1-018

考察：读入数据

因为存在输入是05 07这种，所以使用cin比较方便

而输出有带0，因此输出时使用printf比较方便

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int hh, mm;
    char c;
    cin >> hh >> c >> mm;
    int sum = hh * 60 + mm;
    if (sum >= 0 && sum <= 12 * 60)
    {
     printf("Only %02d:%02d.  Too early to Dang.",hh,mm);

    }
    else
    {
        int n = hh % 12;
        if (mm > 0)
            n++;
        while (n--)
            cout << "Dang";
    }
    return 0;
}

L1-019

本题需要通过样例判断，剩余酒量为负值的时候倒下而不是为0的时候倒下

L1-020

读入的时候判断当前所在朋友圈的人数,按照题意，若人数 >1则有朋友，标记该人的数组b[t]为1

这样输出的时候只要判断b[t]是否为0，若为0则为帅到没朋友的人

#include <bits/stdc++.h>
using namespace std;
int a[105][1005], b[1000005];
int main()
{
    int n, k, m;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> k;
        for (int j = 1; j <= k; j++)
        {
            int t;
            cin >> t;
            if (k > 1)
                b[t] = 1;
        }
    }
    int q, flag = 0;
    cin >> q;
    for (int i = 1; i <= q; i++)
    {
        int t;
        cin >> t;
        if (b[t] == 0)
        {
            if (flag)
                cout << " ";
            printf("%05d", t), b[t] = 1, flag = 1;
        }
    }

    if (!flag)
        cout << "No one is handsome" << endl;
    return 0;
}#include <bits/stdc++.h>
using namespace std;
int a[105][1005], b[1000005];
int main()
{
    int n, k, m;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> k;
        for (int j = 1; j <= k; j++)
        {
            int t;
            cin >> t;
            if (k > 1)
                b[t] = 1;
        }
    }
    int q, flag = 0;
    cin >> q;
    for (int i = 1; i <= q; i++)
    {
        int t;
        cin >> t;
        if (b[t] == 0)
        {
            if (flag)
                cout << " ";
            printf("%05d", t), b[t] = 1, flag = 1;
        }
    }

    if (!flag)
        cout << "No one is handsome" << endl;
    return 0;
}

L1-023 输出GPLT

这题很好的利用循环结构

记录字符串GLPT数量，按顺序循环判断GPLT是否还有剩余，若有则打印并a[i]--

#include <bits/stdc++.h>
using namespace std;
int a[4];
string ss = "GPLT";
int main()
{
    string s;
    cin >> s;
    for (int i = 0; i < s.length(); i++)
    {
        if (s[i] == 'g' || s[i] == 'G')
        {
            a[0]++;
        }
        if (s[i] == 'p' || s[i] == 'P')
        {
            a[1]++;
        }
        if (s[i] == 'l' || s[i] == 'L')
        {
            a[2]++;
        }
        if (s[i] == 't' || s[i] == 'T')
        {
            a[3]++;
        }
    }
    while (a[0] || a[1] || a[2] || a[3])
    {
        for (int i = 0; i < 4; i++)
            if (a[i])
                cout << ss[i], a[i]--;
    }
    return 0;
}