第03章_数组和字符串

原创 2012年03月25日 13:52:38

03_数组和字符串

Example_0301_逆序输出_数组.cpp

Example_0302_开灯问题.cpp

Example_0303_蛇形填数.cpp

Example_0304_竖式问题.cpp

Example_0305_最长回文子串_预处理方法.cpp

Exercise_0301_分数统计(stat)_vector_pair.cpp

Exercise_0302_单词的长度(word)_string.cpp

Exercise_0303_乘积的末3(product)_cctype.cpp

Exercise_0304_计算器(calculator)_simple.cpp

Exercise_0305_方阵旋转(rotate).cpp

Exercise_0306_进制转换1(base1)_十进制转x进制.cpp

Exercise_0307_进制转换2(base2)_x进制转十进制.cpp

Exercise_0308_手机键盘(keyboard).cpp

 

// Example_0301_逆序输出_数组.cpp

/**
 * 题目名称:逆序输出
 * 题目描述:将数组内的数逆序输出。
 **/

#include <stdio.h>
#define MAXN 100 + 10
                       // 为保险起见,这里将数组的最大值声明得稍大一些
int a[MAXN];           // 比较大的数组应尽量声明在main函数外
                       // 附: 全局变量在静态存储区分配内存
                       //      局部变量在栈上分配内存空间

int main()
{
    int i, x, n = 0;
    while(scanf("%d", &x) == 1){
        a[n++] = x;
    }
    for (i = n - 1; i >= 1; i--){
        printf("%d ", a[i]);
    }
    printf("%d\n", a[0]);
    return 0;
}


 

// Example_0302_开灯问题.cpp

/**
 * 题目名称:开灯问题
 * 题目描述:
 *      有n盏灯,编号为1~n。第1个人把所有灯打开,第2个人按下所有编号为2的总数的开关(这些灯将补关掉),
 * 第3个人按下所有编号为3的倍数的开关(其中关掉的灯将被打开,开着的灯将被关掉),依此类推。
 * 一共有k个人,问最后有哪此灯开着?输入n和k,输出开着的灯的编号。 k <= n <= 1000.
 * 样例输入: 7 7
 * 样例输出: 1 5 6 7
 **/

/**
 * 题目分析:
 *     这题并不难,只需要使用两个循环即可实现。
 * 首先,我们可以先去理解一下开关灯实际上是什么,可以知道,开关灯,实际上是一种状态。
 * 那么,我们可以使用一个数值来代表这种状态,下面的程序,用数值1表示开灯,数值0表示关灯。
 * 由于这里有1 ~ n 盏灯,我们可以用一个数组来存放这n盏灯的信息。
 * 解决开关灯状态问题后,可以开始算法思路:
 * 题目中,要求第n个人就会将编号为n的倍数的灯的状态值改变,那么,我们可以在一个循环中负责实现“人”的改变。
 * 然后,再在这个“人”的改变的循环中再嵌入一个处理”灯“的状态改变的函数。
 **/

#include <stdio.h>
#include <string.h>
#define MAXN 1000 + 10
int a[MAXN];

int main()
{
    int i, j, n, k, first = 1;
    memset(a, 0, sizeof(a));
    scanf("%d%d", &n, &k);
    for (i = 1; i <= k; i++){
        for (j = 1; j <= n; j++){
            if(j % i == 0){     // 无余数时是倍数关系,灯的状态得做出对应的变化
                a[j] = !a[j];
            }
        }
    }
    for ( i = i; i <= n; i++){
        if(a[i]){
            if (first){
                first  = 0;
            }
            else{
                printf(" ");
            }
            printf("%d", i);
        }
    }
    printf("\n");
    return 0;
}


 

// Example_0303_蛇形填数.cpp

/**
 * 题目名称:蛇形填数
 * 题目描述:在n*n方阵里填入1, 2, ..., n*n, (n <=8)要求填成蛇形(多余的空格只是为了便于观察规律,不必严格输出)。
 * 样例输入: 4
 * 样例输出:
 *             10 11 12 1
 *              9 16 13 2
 *              8 15 14 3
 *              7  6  5 4
 **/

/**
 * 题目分析:
 *     这里主要用到的是二维数组的知识,还有有点类似“迷宫”的一个判断方法。
 *     首先原题说需要n*n (n <= 8)的方阵,那么,我们只需要定义一个a[n][n]的数组即可。
 *     接下来,观察输出矩阵的蛇形规律,将数组中的每一元素初始化为0,将数字“1“从右上角开始填写,
 * 然后,一直沿着 下 -> 左 -> 上 -> 右 的方向填充数字,直到全部0都填完为止。
 * 那么,我们需要解决的问题,就只有如何能让它按这个方向走呢?我们可以将本来的0作为是否需要填充标记,
 * 再将数组的边界作为另一个是否越界的标记。总之,就是根据这些标记,沿着指定方向,填充到不能填充为止。
 * 最后,要解决的问题就是,如何知道它已经全部填充完了,然后跳出这个循环呢?我们可以用它本来需要填充的
 * 数字个数作为标记,当它的数值小于方阵的总格子个数时,即符合要求。当然,需要注意的一个问题就是,当进行
 * 确定它移动方向的判断时,需要先从数组边界作为越界条件去判断,然后再从数值上判断,这是为了防止内存溢出
 * 的情况出现。
 **/

#include <stdio.h>
#include <string.h>
#define MAXN 10

int a[MAXN][MAXN];

int main()
{
    int n, x, y, tot = 0;
    scanf("%d", &n);
    memset(a, 0, sizeof(a));
    tot = a[x = 0][y = n - 1] = 1;
    while(tot < n * n){
        while(x + 1 < n && !a[x + 1][y]) a[++x][y] = ++tot;     // 下
        while(y - 1 >= 0 && !a[x][y -1]) a[x][--y] = ++tot;     // 左
        while(x - 1 >= 0 && !a[x - 1][y]) a[--x][y] = ++tot;    // 上
        while(y + 1 < n && !a[x][y + 1]) a[x][++y] = ++tot;     // 右
    }
    for (x = 0; x < n; x++){        // 行输出
        for (y = 0; y < n; y++){    // 列输出
            printf("%3d", a[x][y]);
        }
        printf("\n");
    }
    return 0;
}


 

// Example_0304_竖式问题.cpp

/**
 * 题目名称:竖式问题
 * 题目描述:
 *      找出所有形如abc*de(三位数乘以两位数)的算式,使得在完整的竖式中,所有数字都属于一个特定的数字集合。
 * 输入数字集合(相邻数字之间没有空格),输出所有竖式。每个竖式前应有编号,之后应有一行空行。最后输出解的总数。
 * (为了便于观察,竖式中的空格改用小数点显示,但你的程序应该输出空格,而非小数点)。
 * 样例输入: 2357
 * 样例输出:
 * <1>
 * ..775
 * X..33
 * -----
 * .2325
 * 2325.
 * -----
 * 25575
 *
 * The number of solutions = 1
 **/

 /**
  * 题目分析:
  * 尝试所有的abc和de,判断是否满足条件 if (" abc *de")是个合法的竖式)打印abc*de的竖式和其后的空行。
  * 其实主要还是要找出主要需要解决的条件,在这题里面,需要解决的问题主要有两个。
  * 第一个:输出格式控制,这个主要对cout或者prinf的使用方法熟悉即可,
  * 第二个:“所有数字都属于一个特定的数字集合”,这里需要掌握筛选数字的技巧,下例中使用了“缓冲区”的方法。
  *          首先,申请两个字符数组,第一个字符数组用于存放用户输入的字符,第二个字符数组用于存放进行乘法时出现过的数字的保存。
  *          开始执行的过程,
  *          第一步,将用户输入数字集合放到s字符组中。
  *          第二步,计算,然后将计算时所有出现过的数字存放到另一个字符数组buf中。
  *          第三步,开始逐个比较,判断是否buf中每个字符都能从s字符组中找到,起到了最终的筛选作用。
  **/

  #include <stdio.h>
  #include <string.h>

  int main()
  {
      int i, ok, abc, de, x, y, z, count = 0;
      char s[20], buf[99];
      scanf("%s", s);           // 要求用户输入数字集合,并将数字集合放入到字符组s[20]中。
      for (abc = 111; abc <= 999; abc++){ // 这两个循环是为了列举所有的两位数和三位数的数字集合
          for (de = 11; de < 99; de++){
              x = abc * (de % 10);
              y = abc * (de / 10);
              z = abc * de;
              sprintf(buf, "%d%d%d%d%d", abc, de, x, y, z); // 将计算结果得出的数字全部放入到buf字符组中
              ok = 1;
              for(i = 0; i < strlen(buf); i++){
                  if (strchr(s, buf[i]) == NULL){  // 测试buf字符组中的每一个字符是否都能从s字符组中找出
                      ok = 0;
                  }
              }
              if(ok){
                  printf("<%d>\n", ++count);
                  printf("%5d\nX%4d\n-----\n%5d\n%4d\n-----\n%5d\n\n", abc, de, x, y, z);
              }
          }
      }
      printf("The number of solutions = %d\n", count);
      return 0;
  }

// 补充: #include <stdio.h>  int sprintf( char *buffer, const char *format, ... );
// sprintf()函数和printf()类似, 只是把输出发送到buffer(缓冲区)中.返回值是写入的字符数量.

// 补充: #include <string.h>  char *strchr( const char *str, int ch );
// 功能:函数返回一个指向str 中ch 首次出现的位置,当没有在str 中找ch到返回NULL。
// 在C++里面可以用#include <cstring>  size_type find( char ch, size_type index );




 

// Example_0305_最长回文子串_预处理方法.cpp

/**
 * 题目名称:最长回文子串
 * 题目描述:
 *      输入一个字符串,求出其中最长的回文子串。子串的含义是:在原串中连续出现的字符串片段。
 * 回文的含义是:正着看和倒着看相同,如abba和yyxyy。在判断时,应该忽略所有标点符号和空格,
 * 且忽略大小写,但输出应保持原样(在回文串的首部和尾部不要输出多余字符)。输入的字符串长度
 * 不超过5000,且占据单独一行。应该输出最长的回文串,如果有多个,输出起始位置最靠左的。
 * 样例输入: Confuciuss say: Madam, I'm Adam.
 * 样例输出: Madam, I'm Adam.
 **/

 /**
  * 温馨提示:
  * 1. 使用fgetc(fin)可以从打开的文件fin中读取一个字符。
  * 2. 不同操作系统的回车换行符是不一致的。
  *     Windows是'\r'和'\n'两个字符,Linux是'\n',而MacOS是'r'.
  * 3. fgets(buf, MAXN, fin)读取完整的一行,
  *     (相当于C++里面的 istream &getline( char *buffer, streamsize num, char delim );)
  **/

  /**
   * 题目分析:
   * 下面程序的主要思路概括:
   * 1. 预处理,提取转换所有的字符串。
   * 2. 遍历,设区间,比较,设标记。
   * 3. 得出结果,还原输出。
   *
   * 1. 关于预处理,下面通过了使用isalpha判断是否字母,如是字母则将原字符转换为小写放入新字符串。
   *    在放入时,还另外使用了一个数组p,用以保存预处理后的字符在原字符串中的位置,方便还原。
   * 2. 关于如何遍历比较,这里使用了循环变量i作为中心,然后再设一循环j,作为两边散开的点,作为比较点。
   *    如:现在由i做中心,长度区间为 j - i 至 j + 1;   那么,在比较时,就会 j - i 与 j + i 比较,
   *        j不断减小,如果到最后它们也不跳出循环,就使用max,x, y保存现在的位置,暂作为符合条件的最长子字符串。
   *    刚刚所说的是j - i 和j + i 这是在考虑子串长度为奇数的时候所使用的,它会以i为中心向两边散开, j 0 0 i 0 0 j
   *    当其为偶数的时候, 需要以i中左偏中心,然后,再向两边散开比较, 如: j - i 至j + i + 1 ,理解为: j 0 i 0 0 j
   * 3. 几个比较重要的变量 max : 保存最大子串的长度, p[m],本身下标为对应的预处理后的下标,值为原串的下标。
   **/

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#define MAXN 5000 + 10

char buf[MAXN], s[MAXN];
int p[MAXN];

int main()
{
    // 初始化
    int n, m = 0, max = 0, x, y;
    int i, j;
    fgets(buf, sizeof(s), stdin);
    n = strlen(buf);

    // 预处理(字符串转换)
    for (i = 0; i < n; i++){
        if(isalpha(buf[i])){
            p[m] = i;
            s[m++] = toupper(buf[i]);
        }
    }

    // 数据判断(判断是否回文串)
    for( i = 0; i < m; i++){
        for (j = 0; i - j >= 0 && i + j < m; j++){ // 这里是为了比较总长度为奇数的子字符串
            if (s[i - j] != s[i + j]){
                break;
            }
            if (j * 2 + 1 > max) {
                max = j * 2 + 1;
                x = p[i - j];
                y = p[i + j];
            }
        }
        for (j = 0; i - j >= 0 && i + j + 1 < m; j++){// 这里是为了比较总长度为偶数的子字符串
            if (s[i - j] != s[i + j + 1]){
                break;
            }
            if (j * 2 + 2 > max){
                max = j * 2 + 2;
                x = p[i - j];
                y = p[i + j + 1];
            }
        }
    }

    // 结果输出
    for ( i = x; i <= y; i++){
        printf("%c", buf[i]);
    }
    printf("\n");
    return 0;
}

/**
 * 模拟输出过程:
 * Confuciuss say: Madam, I'm Adam.
 *
 * i = 0     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 0 i + j = 0 m = 24
 * 第一个for的max 1 然后用x 与 y 保存 i - j与i+j的值
 *
 * 第二个for: j = 0 i - j = 0 i + j + 1 = 1 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 1     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 1 i + j = 1 m = 24
 * 第一个for: j = 1 i - j = 0 i + j = 2 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 1 i + j + 1 = 2 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 2     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 2 i + j = 2 m = 24
 * 第一个for: j = 1 i - j = 1 i + j = 3 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 2 i + j + 1 = 3 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 3     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 3 i + j = 3 m = 24
 * 第一个for: j = 1 i - j = 2 i + j = 4 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 3 i + j + 1 = 4 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 4     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 4 i + j = 4 m = 24
 * 第一个for: j = 1 i - j = 3 i + j = 5 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 4 i + j + 1 = 5 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 5     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 5 i + j = 5 m = 24
 * 第一个for: j = 1 i - j = 4 i + j = 6 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 5 i + j + 1 = 6 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 6     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 6 i + j = 6 m = 24
 * 第一个for: j = 1 i - j = 5 i + j = 7 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 6 i + j + 1 = 7 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 7     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 7 i + j = 7 m = 24
 * 第一个for: j = 1 i - j = 6 i + j = 8 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 7 i + j + 1 = 8 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 8     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 8 i + j = 8 m = 24
 * 第一个for: j = 1 i - j = 7 i + j = 9 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 8 i + j + 1 = 9 m = 24
 * 第二个for的max 2 然后用x 与 y 保存 i - j与i+j+1的值
 * 第二个for: j = 1 i - j = 7 i + j + 1 = 10 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 9     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 9 i + j = 9 m = 24
 * 第一个for: j = 1 i - j = 8 i + j = 10 m = 24
 * 第一个for的max 3 然后用x 与 y 保存 i - j与i+j的值
 * 第一个for: j = 2 i - j = 7 i + j = 11 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 9 i + j + 1 = 10 m = 24
 * 第二个for: j = 1 i - j = 8 i + j + 1 = 11 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 10     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 10 i + j = 10 m = 24
 * 第一个for: j = 1 i - j = 9 i + j = 11 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 10 i + j + 1 = 11 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 11     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 11 i + j = 11 m = 24
 * 第一个for: j = 1 i - j = 10 i + j = 12 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 11 i + j + 1 = 12 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 12     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 12 i + j = 12 m = 24
 * 第一个for: j = 1 i - j = 11 i + j = 13 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 12 i + j + 1 = 13 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 13     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 13 i + j = 13 m = 24
 * 第一个for: j = 1 i - j = 12 i + j = 14 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 13 i + j + 1 = 14 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 14     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 14 i + j = 14 m = 24
 * 第一个for: j = 1 i - j = 13 i + j = 15 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 14 i + j + 1 = 15 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 15     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 15 i + j = 15 m = 24
 * 第一个for: j = 1 i - j = 14 i + j = 16 m = 24
 * 第一个for: j = 2 i - j = 13 i + j = 17 m = 24
 * 第一个for的max 5 然后用x 与 y 保存 i - j与i+j的值
 * 第一个for: j = 3 i - j = 12 i + j = 18 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 15 i + j + 1 = 16 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 16     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 16 i + j = 16 m = 24
 * 第一个for: j = 1 i - j = 15 i + j = 17 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 16 i + j + 1 = 17 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 17     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 17 i + j = 17 m = 24
 * 第一个for: j = 1 i - j = 16 i + j = 18 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 17 i + j + 1 = 18 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 18     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 18 i + j = 18 m = 24
 * 第一个for: j = 1 i - j = 17 i + j = 19 m = 24
 * 第一个for: j = 2 i - j = 16 i + j = 20 m = 24
 * 第一个for: j = 3 i - j = 15 i + j = 21 m = 24
 * 第一个for的max 7 然后用x 与 y 保存 i - j与i+j的值
 * 第一个for: j = 4 i - j = 14 i + j = 22 m = 24
 * 第一个for的max 9 然后用x 与 y 保存 i - j与i+j的值
 * 第一个for: j = 5 i - j = 13 i + j = 23 m = 24
 * 第一个for的max 11 然后用x 与 y 保存 i - j与i+j的值
 *
 * 第二个for: j = 0 i - j = 18 i + j + 1 = 19 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 19     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 19 i + j = 19 m = 24
 * 第一个for: j = 1 i - j = 18 i + j = 20 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 19 i + j + 1 = 20 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 20     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 20 i + j = 20 m = 24
 * 第一个for: j = 1 i - j = 19 i + j = 21 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 20 i + j + 1 = 21 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 21     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 21 i + j = 21 m = 24
 * 第一个for: j = 1 i - j = 20 i + j = 22 m = 24
 * 第一个for: j = 2 i - j = 19 i + j = 23 m = 24

 * 第二个for: j = 0 i - j = 21 i + j + 1 = 22 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 22     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 22 i + j = 22 m = 24
 * 第一个for: j = 1 i - j = 21 i + j = 23 m = 24
 * 第一个for比较出i-j与i+j的字符不同,break出循环。
 *
 * 第二个for: j = 0 i - j = 22 i + j + 1 = 23 m = 24
 * 第二个for比较出i-j与i+j+1的字符不同,break出循环。
 *
 * i = 23     下面开始进行新一轮
 *
 * 第一个for: j = 0 i - j = 23 i + j = 23 m = 24
 *
 * 结果: Madam, I'm Adam
 * 请按任意键继续. . .
 **/


 

// Exercise_0301_分数统计(stat)_vector_pair.cpp

/**
 * 题目名称:分数统计(stat)
 * 题目描述:
 *      输入一些学生的分数,哪个分数出现的次数最多?如果有多个并,从小到大输出。
 * 分数均为不超过100的非负实数,但最多保留两位小数。
 * 样例输入:11 11 12 12 13 13 14 14 15 16 18 39 a
 * 样例输出:11.00 分数出现了 2 次。
 * 12.00 分数出现了 2 次。
 * 13.00 分数出现了 2 次。
 * 14.00 分数出现了 2 次。
 * 请按任意键继续. . .
 **/

/**
 * 题目分析:
 *
 * 需要进行的操作及需要满足的条件:
 * 1. 输入不确定学生数目的分数
 * 2. 找出相同分数出现的最多次数。
 * 3. 如有重复的最多次数,将其从小到大输出。
 * 4. 输出时进行格式控制,最多保留两位小数。
 *
 * 程序主要思路:
 * 1. 初始化与输入,输入到unsignedDoubleGroup中
 * 2. 获取在double向量组中每个成员出现的次数将其放入maxNumber向量组中.
 * 3. 找出分数出现次数的最大值
 * 4. 查找拥有相同最大值的数据有哪些,并将这些全部保存入result向量组中
 * 5. 输出result向量组中的结果.
 *
 * 思路再分析:
 * 1. 为了满足条件1,我们可以直接使用一个while(cin >> double)的方式来输入保存数据,将数据保存至vector中,
 *    因为需要多次重复使用这些数据,而且不知道数据的数量,所以就选择了vector。
 * 2. 获取每个成员出现次数的方法,可以先将这个vector中的数据提取出来,然后对该数组内的数逐个比较。
 * 3. 找出一组数中哪个是最大值,可直接遍历一次向量组。
 * 4. 为了判断是否有相同最大值的数据,我们还是需要遍历一次向量组,在找出有相同的最值时,这个最值对应的
 *    向量组中的这个元素放到新建的一个result向量组中保存结果。
 * 5. 遍历输出这个result向量组的结果。
 *
 **/

#include <iostream>
#include <vector>
#include <utility>

using std::cin;
using std::cout;
using std::endl;
using std::ios_base;

int main()
{
    // 1. 初始化与输入,输入到unsignedDoubleGroup中
    std::vector<double> unsignedDoubleGroup;
    double unsignedDouble = -1.0;
    while(cin >> unsignedDouble){
        unsignedDoubleGroup.push_back(unsignedDouble);
    }
    if (-1.0 == unsignedDouble){    // 当一个数值也没有输入的时候可以直接跳出该函数
        return 0;
    }

    // 2. 获取在double向量组中每个成员出现的次数将其放入maxNumber向量组中.
    int groupLong = unsignedDoubleGroup.size();
    std::vector<int> maxNumber(groupLong, 0);    // 长度为groupLong,初值全为0的整型向量组,记录每个数字出现的次数
    for (int i = 0; i < groupLong; ++i){
        const double testInt = unsignedDoubleGroup[i];
        for (int j = 0; j < groupLong; ++j){
            if (testInt == unsignedDoubleGroup[j]){
                maxNumber[i]++;                 // 出现次数相加
            }
        }
    }

    // 3. 找出分数出现次数的最大值
    int maxOne = maxNumber[0];
    for ( int i = 0; i < groupLong; ++i){
        if (maxNumber[i] > maxOne){
            maxOne = maxNumber[i];
            }
    }

    // 4. 查找拥有相同最大值的数据有哪些,并将这些全部保存入result向量组中
    std::pair<int, double> tempPair;
    std::vector< std::pair<int, double> > result;
    for (int i = 0; i < groupLong; ++i){
        if (maxNumber[i] == maxOne){
            bool haveSame(false);
            for ( int j = 0; j < int(result.size()); ++j){
                if (result[j].second == unsignedDoubleGroup[i]){
                    haveSame = true;
                    break;
                }
            }
            if (false == haveSame){
                tempPair.first = maxOne;
                tempPair.second = unsignedDoubleGroup[i];
                result.push_back(tempPair);
            }
        }
    }

    // 5. 输出result向量组中的结果
    cout.precision(2);
    cout.setf(ios_base::fixed, ios_base::floatfield);
    for (int i = 0; i < int(result.size()); ++i){
        cout << result[i].second << " 分数出现了 " << result[i].first << " 次。" << endl;
    }

	system("pause");
    return 0;
}


 

// Exercise_0302_单词的长度(word)_string.cpp

/**
 * 题目名称:单词的长度(word)
 * 题目描述:输入若干个单词,输出它们的平均长度。单词只包含大写字母和小写字母。
 **/

#include <cstring>
#include <iostream>

using namespace std;

int main()
{
    string word;
    long sum = 0;
    long count = 0;
    while (!cin.eof() && cin >> word){
        ++count;
        sum += word.size();
    }
    cout << sum / count << endl;
    return 0;
}


 

// Exercise_0303_乘积的末3位(product)_cctype.cpp

/**
 * 题目名称:乘积的末3位(product)
 * 题目描述:
 *      输入若干个整数(可以是正数、负数或者零),输出它们的乘积的末3位。
 * 这些整数中会混入一些由大写字母组成的字符串,你的程序中应当忽略它们。
 * 样例输入:+1 +2 + -1 -2 k 12 english 54 9876 -111
 * 样例输出:712
 **/

/**
 * 题目分析:
 *     题目难度主要在于参差的数据类型输入。
 * 题目总思路,使用while语句逐个string作为单词输入。
 * 然后通过调用函数bool getInt(...)判断该单词是否整数,另外,再利用该函数的形参将正确的整数返回。
 * 将从函数里面得出的整数与结果相乘,乘后保留末三位整数即可。
 * 其中,关于如何实现bool getInt(string get, int & nowGet)才是难题。实现方法如下:
 * 首先,考虑不是整数的情况,1.字符串为空,返回false, 2.是字母或是仅有一个符号。
 * 除了字符串为空的情况外,我们可以开始考虑字符串不为空的情况,字符串不为空时,存在三种情况,
 * 第一种,带符号的整数,第二种,不带符号的整数,第三种,不是整数。
 * 关于这三种情况,可以使用一个if-else if- else语句来实现,
 * 第一种情况:if ('+' == get[0] || '-' == get[0])带上了符号,可以直接忽略读取第[0]位符号位,然后再
 *               从最尾位开始读取,读取3位数即可停止,当读取途中不满三位数或者碰上符号位时,
 *               立即返回。
 * 第二种情况:if('0' <= get[0] && '9' >= get[0]) 直接是数字的情况下,跟第一种情况的思路基本一致,
 *               直接从最尾位开始取个位数,次尾位取十位数,倒数第三位取百位数。
 * 第三种情况:由于不符合需要的整数的转换条件,只需要直接返回false即可.
 * 另外,如果想将字符型的数字转换成数值,只需要将原来的字符型减去'0'即可得到相对应的数值。
 **/

#include <cstring>
#include <string>
#include <cctype>
#include <cmath>
#include <iostream>

using namespace std;


bool getInt(string get, int & nowGet)
{
	int stringLong = get.length();
	if (0 == stringLong){
		return false;
	}
	nowGet = 0;
	if ('+' == get[0] || '-' == get[0]){ // 带符号的正数或负数
		if (0 == (stringLong - 1)){ // 它只包含了一个符号,则直接返回
			return false;
		}
		for (int j = 0, i = stringLong - 1; i > 0 && i >= stringLong - 3; --i, ++j){
			if ('+' == get[i] || '-' == get[i]){	// 正在循环转换的过程,这个数字不满三位数,遇上了符号,直接跳出
				break;
			}
			nowGet += int(get[i] - '0') * (int) (pow(double(10), j));
		}
		return true;
	}
	else if('0' <= get[0] && '9' >= get[0]){ // 直接是数字的情况下
		for (int j = 0, i = stringLong - 1; i >= 0 && i >= stringLong - 3; --i, ++j){
			nowGet += int(get[i] - '0') * (int) (pow(double(10), j));
		}
		return true;
	}
	else{	// 是字母
		return false;
	}
}

int main()
{
    string word;
    long result = 1;
    while(cin >> word){
		int temp;
		if (getInt(word, temp))
		{
			result = (result * temp) % 1000;
		}
    }
	cout << result << endl;
    return 0;
}


 

// Exercise_0304_计算器(calculator)_simple.cpp

/**
 * 题目名称:计算器
 * 题目描述:
 *      编写程序,读入一行恰好包含一个加号、减号或乘号的表达式,输出它的值。
 * 这个运算符保证是二元运算符,且两个运算符均不超过100的非负整数。
 * 运算符和运算符可以紧挨着,也可以用一个或多个空格、TAB隔开。行首末尾均可以有空格。
 * 样例输入: 1+1
 * 样例输出: 2
 * 样例输入: 2- 5
 * 样例输出: -3
 * 样例输入: 0 *1982
 * 样例输出: 0
 **/

#include <iostream>

using namespace std;

int main()
{
    int a, b;
    char oper;
    cin >> a;
    do{
        cin.get(oper);          // 这题只要灵活运用 istream &get( char &ch );
    }while(!('+' == oper || '-' == oper  || '*' == oper) );
    cin >> b;
    if('+' == oper){
        cout << a + b << endl;
    }
    else if('-' == oper){
        cout << a - b << endl;
    }
    else{  // *
        cout << a * b << endl;
    }
    return 0;
}


 

// Exercise_0305_方阵旋转(rotate).cpp

/**
 * 题目名称:矩阵旋转(rotate)
 * 题目描述:输入一个n*n字符矩阵,把它左转90度后输出。
 * 样例输入:
 *     1     2     3     4
 *     5     6     7     8
 *     9    10    11    12
 *     13    14    15    16
 * 样例输出:
 *     4     8    12    16
 *     3     7    11    15
 *     2     6    10    14
 *     1     5     9    13
 **/

 /**
  * 题目分析:
  *     这题其实很简单,刚刚开始我还在苦想呢,它究竟左旋时下标间有些什么规律呢?
  * 后来看着看着才发觉,原来啊,只需要将输入输出的顺序调转一下即可,
  * 输入时,按横,列坐标的方式输入;输出时,按先列后横坐标的方式逐列输出。
  * 输入时,i = 0, j = 1, 2, 3....  输出时, j = 3, i = 0, 1, 2...
  * 至于如何知道它是一个多少阶的矩阵,可以使用开方的方法求得。
  **/

#include <queue>
#include <vector>
#include <cmath>
#include <iostream>

using namespace std;

int main()
{
	// 初始化,输入队列,保存元素
    queue<int> allInOne;
    int tempOne;
    while(cin >> tempOne){
        allInOne.push(tempOne);
    }
    double count = allInOne.size();
    int n = int(sqrt(count));

	// 提取并保存元素
    vector<int> init;
    vector< vector<int> > outit;
    for (int i = 0; i < n; ++i){
        for(int j = 0; j < n; ++j){
        init.push_back(allInOne.front());
        allInOne.pop();
        }
        outit.push_back(init);
        init.clear();
    }

	// 按一定顺序输出元素
    for (int j = n - 1; j >= 0; --j){
        for (int i = 0; i < n; ++i){
            cout << outit[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}



 

// Exercise_0306_进制转换1(base1)_十进制转x进制.cpp

/**
 * 题目名称:进制转换(base1)
 * 题目描述:输入基数b(2 <= b <= 10)和正整数n(十进制),输出n的b进制表示。
 **/

 /**
  * 题目分析:
  * 1. 用户输入十进制数值n,基数b。
  * 2. 要求,转换为由基数b的数字。
  * 3. 这里,可以将这最终结果的数字拆分出来,将一个数字,变为一位数就一个数字,最后遍历输出。
  * 4. 假设输入数值为10,基数为3,结果应为201,我们可以试试用加法的思想去想如何转化。
  * 5. 就像以前使用的算盘那样,数值每增大1,就在个位数上加1,当个位数上的1达到基数大小时,需要进位。
  * 6. 进位以后,需要将原数位清零,这较高位加1,然后,再继续判断这较高位是否可以进位,如此循环。
  * 7. 那么,意思是: ++数值 -> 最代位(原数位)++ -> 判断是否达到基数大小 -> 原数位清零 -> 较高位++...
  * 8. 可以看出,除了第一步的操作外,下面的操作已经开始进入循环体了,也就是说,我们需要解决的第一个问题是:
  *    确定要加多少次数值。 这里,只需要将用户输入的数值n做这样的操作即可:while(n--){}
  *    在上面的循环体中,该放些什么呢?循环体中,已经开始数值相加了,也就是说,需要先初始化一个带个位数的东西,
  *    下面程序选择了vector向量 vector <int> save(1, 0),初始化1个元素,值为0,循环体中,还需要一个用来确认位数
  *    的变量,申请int变量int weishu,刚刚开始时第0位,然后,进行位数上的数值递增操作,判断是否与基数相等,
  *    若不相等,则可以继续下一步的相加操作,若相等,则需要先将现在在进行操作的数组清零,然后,再将位数移到下一位,
  *   因为不知道下一位是否已经在vector里面申请了空间,所以,这里需要先做一个weishu与vector数组长度比较,以防止内存
  *    溢出,接下来只需要进入循环不断地判断是否执行进行操作就可以了。
  * 9. 在跳出了while(n--){]后,就意味着数值转换操作全部完毕,然后,只需要按顺序输出刚刚保存的向量就可以了。
  **/

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    int n, b;
    cin >> n >> b;
    vector <int> save(1, 0); // 初始化1个元素,值为0
    while(n--){
        int weishu = 0;
        while(b == ++save[weishu]){ // 此处进行加1的操作,然后判断是否能进位
            save[weishu] = 0;    // 清零进一
            ++weishu;
            if(save.size() < weishu + 1){    // 考虑进一时是否会越界
                save.push_back(0);
            }
        }
    }

    for (int i = save.size() - 1; i >= 0; --i){
        cout << save[i];
    }
    cout << endl;

    return 0;
}


 

// Exercise_0307_进制转换2(base2)_x进制转十进制.cpp

/**
 * 题目名称:进制转换2(base2)
 * 题目描述:输入基数b(2 <= b <= 10)和正整数n(b进制),输出n的十进制表示。
 **/

 /**
  * 题目分析:
  * 1. 这题与上一题题目条件与结果刚刚相反,不过难度却增大了不少。
  * 2. 上一题是十进制转二进制,是已知十进制总数值大小的情况,相当于将数值逐个相加,可以使用进位的方法。
  * 3. 这一题是未知总数值大小,求十进制表示的总数值大小,将b进制的那个数,从最低位开始相减,为零则借位,直到全部位数为零。
  * 4. 这题关键点在于如何找到结束循环的条件,什么时候是借位结束,下面是部分的伪代码:
  *    while(未为全零){ // 这里循环刚刚开始时,可以先设一个bool值,用来标记这个数并非全为零,具体是否真为全零,可在循环中判断。
  *    if(检查到最低位为零){
  *                          bool notAllZero = false; // 非全零标记
  *                          if(这个数值的全部位数都为零){ notAllZero = true;} // 这里的判断方法可以通过遍历每一位数来实现
  *                          else{ notAllZero = false;}
  *                          while(正在操作的位数 == 0){
  *                                将这位数设为最大值; // 这里因为借位,如10-1的时候,本为0的那一位,变成了9
  *                                位数借一位;		   // 将操作的位数借一位
  *                                if(刚刚所借的这一位数 == 0)
  *                                   { continue; 继续这一个循环;} // 因为之前做过判全零的操作,所以这里不用担心会有溢出的情况发生
  *                                else
  *                                   {这一位数数值-1; break;} // 数值正常减1后,借位成功,可以break出循环体
  *                         }
  *    else { 本位数值-1; }   // 最低位不为零时,操作非常简单,将这最低位的数值减1即可.
  *    ++result; // 这是用来记录十进制的总值的,每当成功完成一次减值操作,就可以将十进制这边的数值加1了。相当于将总数值转移到另一变量上保存。
  *    }
  * 5. 要完成刚刚那伪代码,可以知道,只需要初始化几个变量就可以了,表示位数的变量,表示全零的标记...具体实现方法请看代码。
  **/

#include <iostream>
#include <cstring>
#include <string>

using namespace std;

int main()
{
    int b;
	string n;
    cin >> b >> n;
    int result(0);

	const long weishuMaxIndex = n.length() - 1;	// 最大下标代表最低位的数值
	bool notAllZero(true);
	while(notAllZero){
		int weishu = weishuMaxIndex;
		if ('0' == n[weishu]){
		// 判断是否全零,然后结束循环
			notAllZero = false;
			for(int i = weishuMaxIndex; i >= 0; --i){	// 判全零
				if ('0' != n[i]){
					notAllZero = true;
					break;
				}
			}
			if (false == notAllZero){		// 全部为零时,可直接结束循环
				break;
			}
			while('0' == n[weishu]){		// 正在操作的位数上数值为零
				n[weishu] = b + '0' - 1;	// 本位数上的数值设为最大
				weishu = weishu - 1;		// 借一位,然后再开始判断操作
				if ('0' == n[weishu]){		// 还是为零的话,继续循环操作
					continue;
				}
				else{						// 否则,可以数值减一,跳出循环,继续总体的下一步操作
					n[weishu] = n[weishu] - 1;
					break;
				}
			}
		}
		else{
			n[weishu] = n[weishu] - 1;
		}
		++result;
	}
	cout << result << endl;

	system("pause");
    return 0;
}



 

// Exercise_0308_手机键盘(keyboard).cpp

/**
 * 题目名称:手机键盘(keyboard)
 * 题目描述:输入一个由小写字母组成的英文单词,输出用手机的默认英文输入法的敲键序列。
 * 样例输入:pig
 * 样例输出: p1i3i1
 **/

 /**
  * 题目分析:
  * 题目条件有4: 1. 九宫格 2. 用户输入英文单词 3. 根据九宫格输出按键顺序 4. 当按键前后相同时,需要输出同一字母
  * 首先,了解手机键盘上的九宫格是: (数字)1:(内容)空, 2:abc, 3:def, 4:ghi, 5:jkl, 6:mno, 7:pqrs, 8:tuv, 9:wxyz
  * 然后,要求用户输入一个单词。
  * 接着,输出这个按键序列,只需要使用一个switch语句判断每个字母需要在键盘上按键的数目,保存这个数目即可,另外再与现在的单词同步输出。
  * 最后,因为它还有一个条件需要去判断按键前后是否相同,我们可以再申请两个变量,用以保存前后两次的按键,再进行判断输出。
  * 另外,下面程序将preChar与nowChar初始化为不同的是为了防止第一次比较时会出现溢出,当它们相同的时候,会输出上一个字符,而首次输出时并不存在上一个字符之说。
  **/

#include <iostream>
#include <cstring>
#include <string>

using namespace std;

int main()
{
    string word;
	cin >> word;
	long wordLongMax = word.length();

	for(int wordLong = 0, preChar = 1, nowChar = 0; wordLong < wordLongMax; ++wordLong){
		int count = 0;
		switch(word[wordLong]){
			// 键盘上的数字2
			case 'a':	count = 1; nowChar = 2; break;
			case 'b':   count = 2; nowChar = 2; break;
			case 'c':   count = 3; nowChar = 2; break;
			// 键盘上的数字3
			case 'd':	count = 1; nowChar = 3; break;
			case 'e':   count = 2; nowChar = 3; break;
			case 'f':   count = 3; nowChar = 3; break;
			// 键盘上的数字4
			case 'g':	count = 1; nowChar = 4;  break;
			case 'h':	count = 2; nowChar = 4;  break;
			case 'i':	count = 3; nowChar = 4;  break;
			// 键盘上的数字5
			case 'j':	count = 1; nowChar = 5;  break;
			case 'k':	count = 2; nowChar = 5;  break;
			case 'l':	count = 3; nowChar = 5;  break;
			// 键盘上的数字6
			case 'm':	count = 1; nowChar = 6;  break;
			case 'n':	count = 2; nowChar = 6;  break;
			case 'o':	count = 3; nowChar = 6;  break;
			// 键盘上的数字7
			case 'p':	count = 1; nowChar = 7;  break;
			case 'q':	count = 2; nowChar = 7;  break;
			case 'r':	count = 3; nowChar = 7;  break;
			case 's':	count = 1; nowChar = 7;  break;
			// 键盘上的数字8
			case 't':	count = 1; nowChar = 8;  break;
			case 'u':	count = 2; nowChar = 8;  break;
			case 'v':	count = 3; nowChar = 8;  break;
			// 键盘上的数字9
			case 'w':	count = 1; nowChar = 9;  break;
			case 'x':	count = 2; nowChar = 9;  break;
			case 'y':	count = 3; nowChar = 9;  break;
			case 'z':	count = 1; nowChar = 9;  break;

			default:  exit(1);
		}
		if (preChar == nowChar){
			cout << word[wordLong - 1] << count;
		}
		else{
			cout << word[wordLong] << count;
		}
		preChar = nowChar;     // 记录这次的字符是在哪一个区域,方便下次做“是否相同键”的判断
	}
	cout << endl;
    return 0;
}



 

相关文章推荐

数组指针与字符串

  • 2015年11月25日 19:35
  • 468KB
  • 下载

第03章-VTK系统概述(1)

【译者:这个系列教程是以Kitware公司出版的《VTK User’s Guide -11th edition》一书作的中文翻译(出版时间2010年,ISBN: 978-1-930934-23-8),...

字符串指针与字符数组的区别

  • 2015年04月13日 21:48
  • 4KB
  • 下载

分割字符串,放到数组

  • 2014年10月09日 11:00
  • 523B
  • 下载

Objective-C 编程全解-第03章 类和继承

第03章 类和继承 3.1 继承的概念 3.1.1 父类和子类     继承(inheritance):通过扩展或则修改既有类来定义新类的方法叫做继承。     父类(superclass):...

C语言基础,字符串数组

  • 2013年08月08日 12:20
  • 748B
  • 下载

Xcode江湖录-第03章 藏经阁——项目管理 2 对象属性设置之信息选项卡等

第03章 藏经阁——项目管理 3.2 对象管理 3.2.2 对象设置 3.2.2.2 对象属性设置     1.通用(General)选项卡     2.功能(Capabilities)选项...

数组与字符串

  • 2014年04月13日 18:02
  • 583KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:第03章_数组和字符串
举报原因:
原因补充:

(最多只允许输入30个字)