23.12.25 相关题目复习

一、字符串后继

问题描述
     求一个字符串的下一个后继有以下的规则：
     1. 后继从字符串的最后一位开始增加。
     2. 一个大/小字母字符增加成另一个大/小写字母字符（'A' -> 'B', 'B' -> 'C' ... 'Z' -> 'A'，('a' -> 'b', 'b' -> 'c' ... 'z' -> 'a')）。
     3.  一个数字字符增加成另外一个数字字符（'0' -> '1', '1' -> '2' ... '9' -> '0'）；
     4. 如果当前位有进位产生，它左边的字母或数字字符相应的增加（”azz”->”baa”）。
     5. 有可能会出现最左边字符仍有进位的情况，这时在字符串最左边增加一个相应类型的字符。
我们现在要求的是一个字符串的后面n 个后继。
例如：字符串”99999”后面的3个后继分别是”100000”,”100001”,”100002”。

输入格式
输入包括一个字符串s和数字n（1 ≤ n ≤ 100）。
输入保证s中只包含字母和数字字符，长度小于100。
每组输入只包含一组测试数据。

输出格式
输出字符串s的后面n个后继。每个后继单独一行输出。

样例输入
ComPuteR9 4

样例输出
ComPuteS0
ComPuteS1
ComPuteS2
ComPuteS3

#include <stdio.h>
#include <string.h>
//数组倒序函数
void reverse(char *s, int len)
{
    int i, j;
    char temp;

    for (i = 0, j = len-1; i < j; ++i, --j)
    {
        temp = s[i];
        s[i] = s[j];
        s[j] = temp;
    }
}



void print_successor(char *s, int n)
{
    int len_s;
    int carry, dump;
    int i, j;

    len_s = (int)strlen(s);
    for (j = 1; j <= n; ++j)//n次处理
    {
        reverse(s, len_s);

//首先对最低位进行+1处理
        if ('0' <= s[0] && s[0] <= '9')
        {
            carry = (s[0] - '0' + 1) / 10;
            s[0] = (char)((s[0] - '0' + 1) % 10 + '0');
//记住这里必须先算进位 再改变s[0]的值
        }
        else if ('a' <= s[0] && s[0] <= 'z')
        {
            carry = (s[0] - 'a' + 1) / 26;
            s[0] = (char)((s[0] - 'a' + 1) % 26 + 'a');
        }
        else
        {
            carry = (s[0] - 'A' + 1) / 26;
            s[0] = (char)((s[0] - 'A' + 1) % 26 + 'A');
        }

//接下来是改变已知位数
        for (i = 1; i < len_s; ++i)
        {
            if ('0' <= s[i] && s[i] <= '9')
            {
//这里必须先暂存一个下一次的进位，再用原来的进位carry改变s[i]，之后再把暂存进位给carry
                dump = (s[i] - '0' + carry) / 10;
                s[i] = (char)((s[i] - '0' + carry) % 10 + '0');
                carry = dump;
            }
            else if ('a' <= s[i] && s[i] <= 'z')
            {
                dump = (s[i] - 'a' + carry) / 26;
                s[i] = (char)((s[i] - 'a' + carry) % 26 + 'a');
                carry = dump;
            }
            else
            {
                dump = (s[i] - 'A' + carry) / 26;
                s[i] = (char)((s[i] - 'A' + carry) % 26 + 'A');
                carry = dump;
            }
        }

//最后再用多余的carry增添位数
        while (carry > 0)
        {
            if ('0' <= s[i-1] && s[i-1] <= '9')
            {
                dump = carry / 10;
                s[i] = (char)(carry % 10 + '0');
                carry = dump;
            }
            else if ('a' <= s[i-1] && s[i-1] <= 'z')
            {
                dump = carry / 26;
                s[i] = (char)(carry % 26 + 'a' - 1);
                carry = dump;
            }
            else
            {
                dump = carry / 26;
                s[i] = (char)(carry % 26 + 'A' - 1);
                carry = dump;
            }
            ++i;
        }
        s[i] = '\0';
        len_s = i;
        reverse(s, len_s);
        printf("%s\n", s);
    }
}

int main()
{
    char s[205] = { 0 };
    int n;

    scanf("%s %d", s, &n);
    print_successor(s, n);

    return 0;
}

二、最长子串

描述

给定一个只含'0'～'9'、'A'～'Z'、'a'～'z'的字符串（1≤长度≤10000），请你找出其中不含有重复字符的最长子串的长度。

输入

一个字符串

输出

一个整数，表示最长子串的长度

输入样例 1 

abcabcbb
输出样例 1

3
说明：因为无重复字符的最长子串是 "abc"，所以其长度为 3。
输入样例 2 

bbbbb
输出样例 2

1
说明：因为无重复字符的最长子串是 "b"，所以其长度为 1。
输入样例 3 

pwwkew
输出样例 3

3
说明：因为无重复字符的最长子串是 "wke"，所以其长度为 3。

#include <stdio.h>
#include <string.h>
 
int longest_substring(int *t, int len_t)
{
    int position[63] = { 0 };
    int start = 1, end = 0;
    int current_len = 0, max_len = 0;
 
    for (int i = 1; i <= len_t; ++i)
    {
        if (position[t[i]])
        {
            for (int j = start; j < position[t[i]]; ++j)
                position[t[j]] = 0;
            start = position[t[i]] + 1;
            end = i;
            position[t[i]] = i;
            current_len = end - start + 1;
            if (current_len > max_len)
                max_len = current_len;
        }
        else
        {
            position[t[i]] = i;
            end++;
            current_len++;
            if (current_len > max_len)
                max_len = current_len;
        }
    }
 
    return max_len;
}
 
int main()
{
    char s[10002] = { 0 };
    scanf("%s", s);
    int len_s = (int)strlen(s);
 
    int t[10002] = { 0 };
    for (int i = 1; i <= len_s; ++i)
    {
        if ('0' <= s[i-1] && s[i-1] <= '9')
            t[i] = s[i-1] - '0';
        else if ('A' <= s[i-1] && s[i-1] <= 'Z')
            t[i] = 10 + s[i-1] - 'A';
        else
            t[i] = 10 + 26 + s[i-1] - 'a';
    }
 
    int length = longest_substring(t, len_s);
    printf("%d", length);
 
    return 0;
}

三、高级匹配模式

问题描述
    给定两个字符串s和t，判断s是否是t的子序列，即从t中删除若干个（包括0个）字符，将剩余的字符连接起来，即可获得s。字符串s和t长度不超过1000。

输入格式
第一行，字符串t，文本长度<=1000。
第二行，字符串s，文本长度<=1000。

输出格式
若s是t的子序列，输出1，否则输出0

样例输入
ATBhCde His
This
ATBhCde His
That

样例输出
1 
0

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

int is_subseqence(char *t, char *s)
{
    int ptr_t, ptr_s, ptr_temp;
    int len_t, len_s;

    len_t = (int)strlen(t);
    len_s = (int)strlen(s);

        ptr_s = 0;//作为用来遍历s的索引
        ptr_temp =0;//作为用来遍历t的索引
        while (ptr_s < len_s && ptr_temp < len_t)
        {
            if (t[ptr_temp] == s[ptr_s])
            {
                ptr_s++;
                ptr_temp++;
            }
            else
            {
                ptr_temp++;
            }
        }

        if (ptr_s == len_s)
            return 1;

    return 0;
}

int main()
{
    char t[1005] = { 0 };
    char s[1005] = { 0 };

    while (gets(t))
    {
        gets(s);
        printf("%d\n", is_subseqence(t, s));
    }

    return 0;
}