测试代码

字符转换

给定一个字符串，把字符串内的字母转换成该字母的下一个字母，’a’转换为’b’，’z’换成’a’，’Z’换成’A’，例如”aBf”转换结果为”bCg”,字符串内其他字符不改变，给定函数原型，编写函数

void StringChange(const char* input, char *output)
{
    int i, length = strlen(input);

    for (i = 0; i < length; i++){
        if ((input[i] >= 'a' && input[i] < 'z') || (input[i] >= 'A' && input[i] < 'Z')){
            output[i] = (unsigned char)input[i] + 1;//普通字母
        }else if (input[i] == 'z' || input[i] == 'Z'){
            output[i] = (unsigned char)input[i] - 25;//字母表末尾字母
        }else{
            output[i] = input[i];//其他字符
        }
    }
    output[length] = '';//添加字符串结尾标记
}

找整数相同部分

求一个整型数字中有没有相同的部分，例如12386123这个整型数字中相同的部分是123，相同的部分至少应该是2位数，如果有相同部分，则返回1；如果没有，则返回0。

#include <stdio.h>
#define  MAXBITS 32
int same(int num)
{
    char digits[MAXBITS];//缓存num的每一位数值
    int  i, j, length = 0;
    int  k, sameBits = 0;//存储最多相同的位数
    while (num){
        digits[length++] = num % 10;
        num /= 10;
    }
    // 从后往前比较或者从前往后比较是相同的。
    for (i = length-1; i > 0; i--){
        for (j = i-1; j >= 0; ){
            k = 1;//下一次比较的偏移量
            if (digits[i] == digits[j]){
                sameBits = 1;
                while (j-k >= 0 && digits[i-k] == digits[j-k]){
                    k++;
                    sameBits++;
                }
                if (sameBits >= 2) return 1;
            }
            j -= k;
        }
    }
    return 0;
}

int main()
{
    int n;
    while (scanf("%d", &n) != EOF){
        printf("Number %d: %d
", n, same(n));
    }
    return 0;
}

输出重复的英文字母

在字符串中，将重复(重复次数可以两次以上)的英文字符(字符包括a~z、A~Z)挑选出来输出，不重复的不输出。

分析：可以建立一张出现过的字母索引表（字母，字母出现的次数），首先遍历一遍整个字符串，依次判断每个字符是否已经出现过，如果出现，则一定能在字母表中找到该关键字，那么将其对应的出现次数加1；如果没有出现，那么就将这个新出现的字母添加到字母表中，并将出现次数设置为1。遍历完成后，然后遍历一遍字母表，并判断每个字母出现的次数，如果次数大于1，就将对应字母添加到输出字符串中。

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

typedef struct str_count {
    char key;  //关键字
    int  cnt;  //字母出现次数
} table;

void print_repeated(const char* input, char *output)
{
    int i, j, total = 0, length = strlen(input);

    table* char_tb = (table *)calloc(length, sizeof(table));

    for (i = 0; i < length; i++){
        if ((input[i] >= 'a' && input[i] <= 'z') || (input[i] >= 'A' && input[i] <= 'Z')){
            for (j = 0; j < total; j++){//在字母表中查找此字母是否已经出现过
                if (char_tb[j].key == input[i]){
                    char_tb[j].cnt++;//找到该字母,出现次数加
                    break;
                }
            }
            if (j == total){//如果没找到,则将其加入到字母表中
                char_tb[total].key = input[i];
                char_tb[total].cnt = 1;
                total++;//字母表中的元素个数加
            }
        }
    }
    //输出重复字母
    for (i = 0, j = 0; i < total; i++){
        if (char_tb[i].cnt > 1){
            output[j++] = char_tb[i].key;
        }
    }
    output[j] = '';
}

笨笨熊打包篇

森林里的笨笨熊今天可开心啦——他买了新房子，乔迁新喜要搬家了。因此，笨笨熊请了许多好朋友来帮忙搬家，并准备了很多小纸盒用来装需要搬的物品，不过，这些纸盒的容积都是相同的，并且最多只能装两个物品。但是，为了不打扰太多的朋友，笨笨熊想了个“聪明”办法：让每个纸盒使用效率最高(注：只要纸盒容积大于物品的体积之和就认为可以装下；物品体积不会大于纸盒容积)，这样需要的纸盒最少。为了帮助笨笨熊提前通知朋友，请你根据笨笨熊的办法，帮忙算出：需要纸盒的最少数目是多少？

//先排序，然后最大加上次大，依次寻找满足条件的组合
int box_count2(int volume[], int n, int box_size)
{
    int left = 0, right = n-1, count = 0, total;
    int* flag = (int *)calloc(n, sizeof(int));//用于标记对应元素是否已经装箱

    insertion_sort(volume, n);

    printf("Method 2#
");
    while (right >= 0){//从最大向最小寻找
        if (flag[right] == 0 && volume[right] <= box_size){
            printf("[ %d ", volume[right]);//输出满足条件的组合

            flag[right] = 1;//将此物品装箱
            total = volume[right];
            left  = right - 1;
            while (left >= 0){
                //如果左侧物品未装箱并且可以继续加入本箱中
                if (flag[left] == 0 && total + volume[left] <= box_size){
                    printf("%d ", volume[left]);//输出满足条件的组合

                    flag[left] = 1;//将此物品装箱
                    total += volume[left];
                }
                left--;
            }

            //装满一箱
            printf("]
");
            count++;
        }
        right--;
    }

    return count;
}

出租车计费

起步价6元，里程小于等于2公里时间少于10分钟，收取起步价，大于2公里或者时间超过10分钟后，同时按照两种计费方式计算：

（1）按里程计算：每0.5公里收取0.7元（不足0.5公里不计费），大于7公里后，在此基础上，每公里再多收取0.7元作为返程费（不足1公里不计费）；

（2）按照时间计算：每3分钟收取1.4元（不足3分钟不计费）

最终，以二者中较大者作为最终收取费用。

double fee(double miles, unsigned int minutes)
{
    double price = 6.0;//初始化为起步价6元
    double feeByMile = 0.0, feeByTime = 0.0;//分别为按里程计费和按时间计费

    if (miles <= 2.0 && minutes <= 10) return price;//收取起步价
    //如果里程数大于2.0公里
    if (miles > 2.0){
        //每0.5公里收取0.7元（不足0.5公里不计费）
        feeByMile = 0.7 * ((int)((miles - 2.0)/0.5));
        //大于7公里后，在此基础上，每公里再多收取0.7元作为返程费（不足1公里不计费）
        if (miles > 7.0){
            feeByMile += 0.7 * ((int)(miles - 7.0));
        }
    }
    //如果时间超过10分钟
    if (minutes > 10){
        //按照时间计算：每3分钟收取1.4元（不足3分钟不计费）
        feeByTime = 1.4 * ((minutes - 10) / 3);
    }
    //以二者中较大者作为最终收取费用
    price += (feeByMile > feeByTime) ? feeByMile : feeByTime;

    return price;
}

int main(void)
{
    double mile;
    unsigned int minute;

    scanf("%lf %d", &mile, &minute);
    printf("%.1f
", fee(mile, minute));

    return 0;
}

逆序链表输出

输入一个单向链表，将链表逆序后输出各结点的值。

链表结点结构定义如下：

typedef struct tagListNode

{

    int value;

    struct tagListNode *next;

}ListNode;

#include <stdio.h>
#include <stdlib.h>

typedef struct tagListNode {
    int value;
    struct tagListNode *next;
}ListNode;

ListNode* reverse(ListNode *x)
{
    ListNode *t, *y = x, *r = NULL;//r的末尾初始化为NULL
    while (y != NULL){
        t = y->next;
        y->next = r;
        r = y;
        y = t;
    }
    return r;//r指向逆向链表的头部
}
//node指向单向链表末尾元素
int createNode(ListNode* node, int val)
{
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    if (!newNode) return 0;
    node->next = newNode;
    newNode->value = val;
    newNode->next  = NULL;
    return 1;//创建成功
}

int main(void)
{
    int value;
    ListNode *head = NULL, *t = NULL;
    //创建第一个结点
    scanf("%d", &value);
    head  = (ListNode*)malloc(sizeof(ListNode));
    if (!head) return -1;
    head->next = NULL;
    head->value = value;

    t = head;
    while (1 == scanf(",%d", &value)){
        if (createNode(t, value)) t = t->next;
    }

    t = reverse(head);//链表求逆
    while (t != NULL){
        printf("%d", t->value);
        if (t->next != NULL)
            printf(",");
        t = t->next;
    }
    printf("
");
    return 0;
}

心有灵犀一点通

在某相亲节目现场，有n(1≤n≤500)对善男俊女,为测试男女双方心有灵犀程度,主持人想出了一个很有意思的游戏：主持人在地上画出一排(共2n个)格子，每个格子里都写着一个整数Ai(1≤Ai≤500)。游戏开始后，让他们任意地站成一排(可能会有两个人站在了同一个格子里)。等他们都站好以后，司仪开始计算他们每个人自己的得分，记分规则是：男方的分数等于把从自己所站的位置开始一直累加到开头，女方的分数等于从自己所站位置开始一直累加到末尾。如果某一对男女的得分数是相同的，那他们得默契度较高,比较有缘,交友成功率也高。比如，有3对男女，地上的那一排数字为:3，6，2，4，5，2。如果男方站在第三个位置(2)，他的得分为：3+6+2=11；女方站在第4个位置(4)，她的得分为4+5+2=11。两人得分相同，就认为两人很有默契。或者男方站第6个位置(2)，女方站第1个位置(3)，他们的得分都等于22，也很有默契。如果你朋友在节目现场，那么请你帮他/她算一算有多少种站法可以迅速有机会找到那个默契的她/他（参数不合法返回-1）。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BUFF_SIZE 4096

int way(int num[], int length)
{
    int  i, j, ways = 0;//可供选择的站法
    int* boy_score = (int*)calloc(length, sizeof(int));
    int* girl_score = (int*)calloc(length, sizeof(int));
    //初始化男孩每个位置的得分
    boy_score[0] = num[0];
    for (i = 1; i < length; i++){
        boy_score[i] = boy_score[i-1] + num[i];
    }
    //初始化女孩每个位置的得分
    girl_score[length-1] = num[length-1];
    for (j = length-2; j >= 0; j--){
        girl_score[j] = girl_score[j+1] + num[j];
    }

    for (i = 0; i < length; i++){
        for (j = 0; j < length; j++){
            if (boy_score[i] == girl_score[j]) ways++;
        }
    }

    return ways;
}

int main(void)
{
    int couple = 0;//情侣的对数
    int grids  = 0;//存储格子个数
    int number[1000];//存储格子里的数字
    int i, num, len;
    char  buff[BUFF_SIZE];//接收数据缓冲区
    char* temp;//指向缓冲区中一个数字的首字符

    scanf("%d", &couple);
    if (couple < 1 || couple > 500)
    {
        printf("%d", -1);
        return -1;
    }
    //务必清空输入缓冲区,否则fgets()会直接获取前一个scanf()遗留的换行符
    //而不会重新等待输入
    fflush(stdin);
    fgets(buff, BUFF_SIZE, stdin);
    len = strlen(buff);//获取字符串长度
    if (buff[len-1] == '
'){//判断字符串最后是否读入了换行符
        buff[len-1] = ' ';//添加一个数字结尾
    }else{
        buff[len-1] = ' ';//添加一个数字结尾
        buff[len] = '';
        ++len;
    }
    temp = buff;//temp指向缓冲区起始位置
    for (i = 0; i < len; i++){
        if (buff[i] == ' '){//找到一个数字结尾
            buff[i] = '';//将其改为字符串结束符
            num = atoi(temp);//转换为整数
            if (num < 1 || num > 500){
                printf("%d", -1);
                return -1;
            }
            number[grids++] = num;//添加到格子中
            temp = buff + i + 1;//temp移动到下一个数字起始位置
        }
    }

    if (2 * couple != grids){//参数出错
        printf("%d", -1);
        return -1;
    }
    printf("%d", way(number, grids));

    return 0;
}

洞穴逃生

精灵王子爱好冒险，在一次探险历程中，他进入了一个神秘的山洞。在洞穴深处，精灵王子不小心触动了洞穴内暗藏的机关，整个洞穴将很快塌陷，精灵王子必须尽快逃离洞穴。精灵王子的跑步速度为17m/s，以这样的速度可能是无法逃出洞穴的。庆幸的是精灵王子拥有闪烁法术，可在1s内移动60m，不过每次使用闪烁法术都会消耗魔法值10点。精灵王子的魔法值恢复的速度为4点/s，只有处在原地休息状态时才能恢复。

现在已知精灵王子的魔法初值M，他所在洞穴中的位置与洞穴出口之间的距离S，距离洞穴塌陷的时间T。

你的任务是写一个程序帮助精灵王子计算如何在最短的时间内逃离洞穴。若能逃出，输出"Yes"，并输出逃出所用的最短时间；若不能逃出，则输出"No"，同时输出精灵王子在剩下的时间内能走的最远距离。注意字母大小写。注意:精灵王子跑步、闪烁或休息活动均以秒(s)为单位。且每次活动的持续时间为整数秒。距离的单位为米(m)。

注：M、S、T均是大于等于0的整数。由输入保证取值合法性，考生不用检查。

提醒：

如果输入的S为0，则说明本身已经在出口，输出应为：Yes 0

如果输入的T为0（且S不为0），则说明已经没有时间了，输出应为：No 0

#include <stdio.h>
 
int main() {
    int M, S, T;
    int moved = 0, time = 0; // moved 表示王子移动的距离, time 表示王子花掉的时间
    scanf("%d%d%d", &M, &S, &T);
 
    if (S == 0) {
        puts("Yes 0"); 
        return 0;
    } else if (T == 0) {
        puts("No 0"); 
        return 0;
    }
 
    while ( moved < S && time < T ) {
        if ( M >= 10) {    // 情形1：魔法值充分(大于等于10)，优先闪烁
            moved += 60;
            time++;
            M -= 10;
        } else if ( M >= 6 && T - time >= 2 && S - moved > 34 ) {  // 情形2
            moved += 60;
            time += 2;
            M -= 6;  // 这里不能 M -= 10，因为休息1秒后增了4点魔法值，下同
        } else if ( M >= 2 && T - time >= 3 && S - moved > 51 ) {  // 情形3
            moved += 60;
            time += 3;
            M -= 2;
        } else if ( T - time >= 7 && S - moved >= 120 ) {   // 情形4 
            moved += 120;
            time += 7;
        } else {    // 情形5
            int n1 = T - time;
            int n2 = (S - moved + 16 ) / 17;  // 考虑剩余距离不足17m的情况，所以要加上16，不然的话就不能得到1s
            int nn = n1 < n2 ? n1 : n2;
            moved += nn * 17;
            time += nn;
        }
    }
 
    if ( moved >= S) {
        printf("Yes %d
",time);
    } else {
        printf("No %d
",moved);
    }
 
    return 0;
}

计算一行语句中，最后一个单词的长度

#include <stdio.h>
#include <string.h>
#define  BUFFSIZE 128

int main(void)
{
    char buff[BUFFSIZE];
    int  i, length;
    fgets(buff, BUFFSIZE, stdin);
    length = strlen(buff);//注意，回车符也包含在内
    //去掉字符串末尾的回车和空格
    while (buff[length-1] == ' ' || buff[length-1] == '
'){
        buff[length-1] = '';
        length--;
    }
    i = 0;
    //如果不是字符串开始位置并且当前字符不是空格，就向前搜索
    while (length-1-i>=0 && buff[length-1-i] != ' ') i++;
    printf("%d", i);

    return 0;
}

字符逆序

将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。

#include <stdio.h>
#include <string.h>
#define  BUFFSIZE 101

int main(void)
{
    char buff[BUFFSIZE];
    int  i, j, length;
    fgets(buff, BUFFSIZE, stdin);
    length = strlen(buff);//注意，回车符也包含在内
    //去掉字符串末尾的回车
    while (buff[length-1] == '
'){
        buff[length-1] = '';
        length--;
    }
    i = 0;
    j = length - 1;
    // 整个字符串逆序
    while (i < j){//交换i和j所指向的字符
        buff[i] ^= buff[j];
        buff[j] ^= buff[i];
        buff[i] ^= buff[j];
        i++;j--;
    }
    printf("%s", buff);

    return 0;
}

图片整理

#include <stdio.h>
#include <string.h>
#define  BUFFSIZE 101

int division(char a[], int left, int right)
{
    char base = a[left];
    while (left < right){
        while (left < right && base <= a[right]) right--;
        a[left] = a[right];
        while (left < right && base >= a[left]) left++;
        a[right] = a[left];
    }
    a[left] = base;
    return left;
}

void qsort(char a[], int left, int right)
{
    int mid;
    if (left < right){
         mid = division(a, left, right);
         qsort(a, left, mid-1);
         qsort(a, mid+1, right);
    }
}

int main(void)
{
    char buff[BUFFSIZE];
    int  i, j, length;
    fgets(buff, BUFFSIZE, stdin);
    length = strlen(buff);//注意，回车符也包含在内
    //去掉字符串末尾的回车
    while (buff[length-1] == '
'){
        buff[length-1] = '';
        length--;
    }
    // 快速排序
    qsort(buff, 0, length-1);
    printf("%s", buff);

    return 0;
}

找零钱

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

int main(void)
{
    int n100, n50, n20, n10, n5, n2;//各面额的找零张数
    int ways = 0;// ways找零方案数
    int money, temp;//待找零金额
    scanf("%d", &money);
    while (money > 0){// money=0时结束
        ways = 0;// 找零方案数清零
        for (n100 = money/100; n100 >= 0; n100--){
            temp = money - 100*n100;
            for (n50 = temp/50; n50 >= 0; n50--){
                temp = money - 100*n100 - 50*n50;
                for (n20 = temp/20; n20 >= 0; n20--){
                    temp = money - 100*n100 - 50*n50 - 20*n20;
                    for (n10 = temp/10; n10 >= 0; n10--){
                        temp = money - 100 * n100 - 50 * n50 - 20 * n20 - 10 * n10;
                        for (n5 = temp/5; n5 >= 0; n5--){
                            temp = money - 100 * n100 - 50 * n50 - 20 * n20 - 10*n10 - 5*n5;
                            for (n2 = temp/2; n2 >= 0; n2--){
                                temp = money - 100*n100 - 50*n50 - 20*n20 - 10*n10 - 5*n5 - 2*n2;
                                if (temp >= 0){// 还需要元的找零
                                    // 如果找零的张数小于
                                    if (n100 + n50 + n20 + n10 + n5 + n2 + temp <= 100){    
                                        // 方法数加
                                        ways++;
                                        // 输出可行的找零方案
                                        printf("Way[%2d] %d(100) %d(50) %d(20) %d(10) %d(5) %d(2) %d(1)
", ways, n100, n50, n20, n10, n5, n2, temp);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        // 读取下一次输入
        scanf("%d", &money);
    }
    
    return 0;
}