基于陈阿水的解，我自己总结

解题思路:

后k位的循环节是后k-1位循环节的倍数

测试输入输出可以看到，输入是100位，输出也是100位，所以使用数组的方式来计算

使用数组方式编写三个辅助函数

void Reverse_entry(char *in_out);//颠倒字符串函数

将输入的测试数字进行颠倒，让个位在前，十位、百位……在后，计算更方便

编写思路：

                    计算输入数组长

                    设置临时数组

                    令临时数组的值为输入数组

                    将临时数组从尾到头遍历，输入数组从头到尾遍历

                            输入数组值等于临时数组           

void add(char *out,char *in);//函数功能out=out+in

用于输出计数；

编写思路

            遍历in数组

                    对应位out[i]是否为数组尾部

                                是，扩展数组；

                    设置临时值And=in[i]+out[i]

                    令out[i]为And个位

                    And为两和进位

                    从j=i+1开始进位处理，直到进位为0截至

                                先确定进位对应out[j]是否为数组尾部

                                              是，扩展数组；

                                 And=out[j]+And;

                                令out[i]为And个位

                                And为两和进位                   

void All_mult(char *in_1,char*in_2,char*out);//out=in_1*in_2+out；

编写思路：

                遍历in_1数组，i

                        遍历in_2数组，j

                                确定两个数组乘积能被out储存

                                            对应位out[i+j]是否为数组尾部，

                                                           是，扩展数组；

                                            设置临时值And=(out[i]-'0')*(in[i]-'0')+(out[i+j]-'0');//计算位和

                                                令out[i+j]为And个位

                                                And为进位

                                                从j=i+j+1开始进位处理，直到进位为0截至

                                                        先确定进位对应out[j]是否为数组尾部

                                                                  是，扩展数组；

                                                     And=out[j]+And;

                                                    令 out[i]为And个位

                                                       And为两和进位  

主程序

            for循环i=0,w=0/*相同位数*/,p=0/*标志位*/,end=0/*弹出计数*/

            逐个位置确定是否循环

            对两个输出置零；

            num*mult=result

            mult_num*mult=mult_result

            计数加out_assist,初始out_assist=1;

            对标志位p置零

            判断是否有位循环

                    有，w加一，p置一

                    无，i=w，退出

            标志位为1

                        确定w==k，打印结果，退出程序

                        处理out_assist=out

                        处理mult=mult_result

            处理num=result;

            处理mult_num=mult_result

            判断end是否100000次

                    若是跳出循环

例子各值；

注意事项:

参考代码:

#include<stdio.h>

#include<string.h>

#include<stdio.h>

#include<string.h>

void add(char *out,char *in);//函数功能out=out+in

void Reverse_entry(char *in_out);//颠倒字符串函数

void All_mult(char *in_1,char*in_2,char*out);//out=in_1*in_2+out；

int main()

{

    int k;

    char num[102]={'\0'}/*输入值,被乘数*/

    ,check[102]={'\0'}/*检查值*/,mult[102]/*乘数*/

    ,result[102]/*计算结果被检查值*/;

    char out[102],out_assist[102];//输出值，增加节点

    char mult_num[102],mult_result[102];//乘数处理

    scanf("%s %d",num,&k);

    //初始化

    Reverse_entry(num);

    strcpy(check,num);

    strcpy(mult,num);

    out[0]='0';//输出值初始化；

    out[1]='\0';

    out_assist[0]='1';//设置辅助参数

    out_assist[1]='\0';

    mult_num[0]='1';

    mult_num[1]='\0';

    mult_result[0]='1';

    mult_result[1]='\0';

    for(int i=0,w=0,p=0/*标志位*/,end=0;i<=k;++i)

    {

        result[0]='\0';

        mult_result[0]='\0';

        All_mult(num,mult,result);

        All_mult(mult_num,mult,mult_result);

        result[k]='\0';

        mult_result[k]='\0';

        add(out,out_assist);

        p=0;

        for(int j=w;j<k;++j)

        {

            if(result[j]!=check[j])

            {

                i=w;

                break;

            }

            else

            {

                p=1;

                ++w;

            }

        }

        if(p==1)

        {

            if(w==k)//打印结果

            {

                for(int a=strlen(out)-1;a>=0;--a)

                printf("%c",out[a]);

                return 0;

            }

            strcpy(out_assist,out);//w位相同，改变辅助函数

            strcpy(mult,mult_result);

        }  

        strcpy(mult_num,mult_result);

        strcpy(num,result);

        ++end;

        if(end==100000)

            break;

    }

    printf("-1");

}

void Reverse_entry(char *in_out)//颠倒序列为倒序

{

    int len=strlen(in_out);

    char temp[len+1];

    for(int i=0;i!=len+1;++i)

        temp[i]=in_out[i];

    for(int i=len-1,j=0;i>=0;--i,++j)

        in_out[j]=temp[i];

}

void add(char *out,char *in)//函数功能out=out+in

{

    for(int i=0;i!=strlen(in);++i)//遍历in，将in与out逐位相加

    {

        if(out[i]=='\0')//确定out是否为末尾

        {

            out[i]='0';//确定是末尾扩大一位

            out[i+1]='\0';

        }

        int And=(out[i]-'0')+(in[i]-'0');//计算位和

        out[i]='0'+And%10;//位和个位赋予

        And=And/10;//位和进位

        for(int j=i+1;And!=0;++j)//进位逐个相加

        {

            if(out[j]=='\0')

            {

                out[j]='0';

                out[j+1]='\0';

            }

            And=(out[j]-'0')+And;

            out[j]='0'+And%10;

            And=And/10;

        }

    }

}

void All_mult(char *in_1,char*in_2,char*out)//输入in_1,in_2,out

{                                           //函数功能out=in_1*in_2+out

    for(int i=0;i<strlen(in_1);++i)

        for(int j=0;j<strlen(in_2);++j)

            if(i+j<100)

            {

                if(out[i+j]=='\0')

                {

                    out[i+j]='0';

                    out[i+j+1]='\0';

                }

                int And=(out[i+j]-'0')+(in_1[i]-'0')*(in_2[j]-'0');

                out[i+j]=And%10+'0';

                And=And/10;

                for(int k=j+i+1;And!=0;++k)

                {

                    if(out[k]=='\0')

                    {  

                        out[k]='0';

                        out[k+1]='\0';

                    }

                    And=And+(out[k]-'0');

                    out[k]=And%10+'0';

                    And=And/10;

                }

            }

}