DouKaku?

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

int cal(char *ans, size_t bufsize, int a, int b)
{
    const char * const head   = ans;
    char       *jyunkan_start = NULL;  // 循環の始点
    const char *match_start   = NULL; // 
    size_t      match_count   = 0;

    memset(ans, '\0', bufsize);

    a = (a % b) * 10; 
    for( size_t n=1; n<bufsize; n ++, ans ++ )
    {
        // 計算
        *ans = '0' + a / b;
        a = (a % b) * 10;
        if( a == 0 ) break;

        /**********************/
        /* 循環小数のチェック */
        /**********************/
        if( match_start == NULL )
        {
            if( jyunkan_start == NULL )
            {
                jyunkan_start = ans;
                continue;
            }
            if( *jyunkan_start == *ans )
            {
                // 循環の開始位置かもしれない
                match_start = ans;
                match_count ++;
            }
        }
        else
        {
            // 循環の可能性あり
            if( *(jyunkan_start+match_count) == *ans )
            {
                if( (size_t)(match_start-jyunkan_start)==match_count)
                {
                    // ロジック上開始位置がずれるので巻き戻し
                    while( head != jyunkan_start )
                    {
                        if( *(jyunkan_start-1) == *(ans-1))
                        {
                            jyunkan_start --;
                            ans --;
                        }
                        else 
                        {
                            break;
                        }
                    }
                    // 循環部分を {}
                    memmove(jyunkan_start+1, jyunkan_start, match_count);
                    jyunkan_start[0] = '{';
                    jyunkan_start[match_count+1] = '}';
                    jyunkan_start[match_count+2] = '\0';
                    break;
                }
                match_count ++;
            }
            else
            {
                // はずれ
                jyunkan_start ++;
                match_start = NULL;
                match_count = 0;
            }
        }
    }

    return 0;
}

int main(int argc, char *argv[])
{
    char   ans[64]; // 循環する小数部の倍以上必要
    struct {
        int a, b;
        char ans[64];
    } 
    test[] = 
    {
        {  1,  2, "5" },
        {  1,  3, "{3}" },
        {  1,  7, "{142857}" },
        {  3, 14, "2{142857}" },
        { 50, 51, "{9803921568627450}" },
        { 13, 191,"068062827225130890052356020942408376963350785340314136125654450" }
    };

    for( size_t n=0; n<sizeof(test)/sizeof(*test); n++)
    {
        cal(ans, sizeof(ans), test[n].a, test[n].b); 
        printf("ans=0.%s\n", ans);
        assert( strcmp(ans, test[n].ans) == 0 );
    }
    return 0;
}