请一个在字符串中找出连续最长的数字串，并把这个串的长度返回；如果存在长度相同的连续数字串，返回最后一个连续数字串

题目描述

请一个在字符串中找出连续最长的数字串，并把这个串的长度返回；如果存在长度相同的连续数字串，返回最后一个连续数字串；

注意：数字串只需要是数字组成的就可以，并不要求顺序，比如数字串“1234”的长度就小于数字串“1359055”，如果没有数字，则返回空字符串（“”）而不是NULL！

样例输入

abcd12345ed125ss123058789

abcd12345ss54761

样例输出

输出123058789，函数返回值9

输出54761，函数返回值5

接口说明

函数原型：

unsignedint Continumax(char** pOutputstr, char* intputstr)

输入参数：
char* intputstr 输入字符串；

输出参数：
char** pOutputstr: 连续最长的数字串，如果连续最长的数字串的长度为0，应该返回空字符串；如果输入字符串是空，也应该返回空字符串；

返回值：
连续最长的数字串的长度

自己写的代码（想的复杂了有点，哈哈）：

unsigned int Continumax(char** pOutputstr,  char* intputstr)
{
    int flag = 0;
    int count;

    int start_p_front = 0;
    unsigned int len_front = 0;

    int start_p = 0;
    unsigned int len = 0;

    char *resver;

    for(count=0; intputstr[count]!='\0'; count++)  
    {
        if(intputstr[count] >= '0' && intputstr[count] <= '9')
            len++;

        if(len == 1)//记录起始位置
            start_p = count;

        if(count < (strlen(intputstr)-1))//在字符串中间
        {
            if((intputstr[count] < '0' || intputstr[count] > '9') && len != 0)  
                flag = 1;
        }   
        else//在字符串的最后一位
        {
            if(intputstr[strlen(intputstr)-1] >= '0' && intputstr[strlen(intputstr)-1] <= '9')
            {
                flag = 1;
            }
        }

        if(flag == 1)
        {   
            if(len_front <= len)
            {
                start_p_front = start_p;
                len_front = len;
            }

            flag = 0;
            len = 0;
            start_p = 0;
        }               
    }

    if(len_front == 0)
    {
        resver = (char *)malloc(sizeof(char));
        *resver= '\0';//空字符串
    }
    else
    {           
        resver = (char *)malloc(sizeof(char)*(len_front+1));
        for(count=0;  count<len_front; count++)
        {
            *(resver+count) = intputstr[start_p_front+count];
        }
        *(resver+count)  = '\0';

    }

        *pOutputstr =resver;

        return len_front;
}

另外一个版本：

unsigned int Continumax(char** pOutputstr,  char* intputstr)
{
    int flag = 0;
    int count;

    int start_p_front = 0;
    unsigned int len_front = 0;

    int start_p = 0;
    unsigned int len = 0;

    char *resver;

    for(count=0; intputstr[count]!='\0'; count++)  
    {
        if(intputstr[count] >= '0' && intputstr[count] <= '9')
        {   
            len++;
            if(len ==1)
                start_p = count;
        }
        else
        {
            if(len_front<=len)
            {
                len_front = len;
                start_p_front = start_p;
            }
            len = 0;
        }
    }

    if(len_front == 0)
    {
        resver = (char *)malloc(sizeof(char));
        *resver= '\0';//空字符串
    }
    else
    {           
        resver = (char *)malloc(sizeof(char)*(len_front+1));
        for(count=0;  count<len_front; count++)
        {
            *(resver+count) = intputstr[start_p_front+count];
        }
        *(resver+count)  = '\0';

    }

        *pOutputstr =resver;

        return len_front;
}