一、纯循环小数化分数
 
从小数点后面第一位就循环的小数叫做纯循环小数。怎样把它化为分数呢？看下面例题。
 
把纯循环小数化分数：
 
纯循环小数的小数部分可以化成分数，这个分数的分子是一个循环节表示的数，分母各位上的数都是9。9的个数与循环节的位数相同。能约分的要约分。
 
二、混循环小数化分数
 
不是从小数点后第一位就循环的小数叫混循环小数。怎样把混循环小数化为分数呢？ 把混循环小数化分数。
 
先看小数部分0.353
 
一个混循环小数的小数部分可以化成分数，这个分数的分子是第二个循环节以前的小数部分组成的数与小数部分中不循环部分组成的数的差。分母的头几位数是9，末几位是0。9的个数与循环节中的位数相同，0的个数与不循环部分的位数相同。
 
三、循环小数的四则运算
 
循环小数化成分数后，循环小数的四则运算就可以按分数四则运算法则进行。从这种意义上来讲，循环小数的四则运算和有限小数四则运算一样，也是分数的四则运算。
 
有限小数化成分数直接将小数点去掉，分母对应化成十百千万等。再约分。
 
例如：0.333.....＝3/9=1/3
 
0.214214214214214....=214/999
 
简单说每一个循环节为分子，循环节有几位数分母就写几个9
 
0.3333......循环节为3 0.214.....循环节为214
 
0.52525252....循环节为52，所以0.525252...＝52/99
 
0.35....=35/99

给定一个分数，判断其是否是一个无限循环小数，并输出它的第一个循环节。
 
例如：分数 1/3 是一个无限循环小数，第一个循环节为 3；而 2/5 不是一个无限循环小数。
 
输入格式
 不多于 100 行，每行一个 m/n 形式的分数（0<m<n<100000)
 
输出格式
 对于每一个分数，当其是一个无限循环小数时，输出它的第一个循环节；否则输出 0。每行的最后有一个换行符。
 
样例
 input
 1/3
 2/5
 16/30
 4/7
 1/99
 output
 3
 0
 3
 571428
 01
 
提示
 4/7的计算过程： 4/7=0余4，即结果为0余数为4； 410=40、40/7=5余5，即结果为0.5余数为5； 510=50、50/7=7余1，即结果为0.57余数为1； 110=10、10/7=1余3，即结果为0.571余数为3； 310=30、30/7=4余2，即结果为0.5714余数为2； 210=20、20/7=2余6，即结果为0.57142余数为6； 610=60、60/7=8余4，即结果为0.571428余数为4； 由于在计算过程中余数4出现过，后面的计算过程即将重复，即找到了循环节571428。
 
代码
 
#include<bits/stdc++.h>
using namespace std;
int main() {
    char c;
    int m, n, i;
    while (scanf("%d/%d", &m, &n) != EOF) {
        int nums[100001] = {0};
        string res = {}, ans;
        i = 1;
        nums[m] = i++;
        int left;
        while (m != 0) {
            m *= 10;
            left = m / n;
            res += to_string(left);
            m = m % n;
            if (nums[m]) {
            //注意此处循环的上下界
                for (int j = nums[m]-1; j < i-1; j++)
                    printf("%c",res[j]);
                printf("\n");
                break;
            }
            else {
                nums[m] = i++;
            }
        }
        if (m==0) printf("0\n");
    }
}

 
变式题：分数的精确值
 
计算机内部表示的浮点数只有有限的精确位数。现在要找一种方法，使一个分数的精确值能够被表示为十进制小数，如果是一个无限循环小数，则指出它从哪一位到哪一位是循环节。
 
输入格式
 第 1 行：整数 () 为问题数
 
第 2 ∽ T+1 行：每行为每一个问题中的用一个空格分隔的分子 n 和分母 m （）。
 
输出格式
 对于每个问题，输出一行问题的编号（0 开始编号，格式：case #0: 等），然后在一行中输出精确值小数（无循环）或一个小数直到第一个循环节结束。如果有循环，则在下一行中以两个整数表示从哪一位到哪一位是循环节，中间用一个 “-” 号分隔。
 
样例
 input
 2
 2 4
 47 48
 output
 case #0:
 0.5
 case #1:
 0.97916
 5-5
 
大佬思路：利用hash存储。
 
#include <cstdint>
#include <iostream>
#include <unordered_map>

int main() {
    using u32 = uint32_t;
    u32 t;
    std::cin >> t;
    for (u32 i = 0; i != t; ++i) {
        u32 n, m;
        std::cin >> n >> m;
        std::cout << "case #" << i << ":\n" << n / m;//输出整数部分
        n = n % m * 10;
        if (!n) {
            std::cout << '\n';
            continue;
        }
        std::cout << '.';
        using BitPos = u32;
        using Dividend = u32;
        u32 bit_cnt = 1;
        std::unordered_map<Dividend, BitPos> table{{n, bit_cnt}};//被除数，以及其出现位数
        do {
            std::cout << n / m;
            n = n % m * 10;
            if (auto [it, ok] = table.insert({n, bit_cnt += 1}); !ok) {
                std::cout << '\n' << it->second << '-' << bit_cnt - 1;
                break;
            }
        } while (n);
        std::cout << '\n';
    }
}

题目名称：循环小数
 
题目描述：
 
输入整数a和b a大于等于0小于等于3000,b大于等于1小于等于3000,输出a/b的循环小数表示以及循环节长度。如果循环周期大于50,只显示50位，之后的全部用……表示
 
样例：
 
Alt text 
 题目分析： 
 ①所谓的循环小数，也就是我们理解的当每步作除法时候，会出现了重复的商，那个循环小数的周期肯定就在两个重复的商之间。 
 ②现在就转化为类似于找周期的问题了，找重复出现的商，我们最常见想到的办法就是记录所有的商，每算出一个新的商，之后就顺序查找看该商是否出现过，这就比较复杂了，复杂度为O(n^2) 
 ③改进方法就是我们可以考虑用一个数组记录某个商是否出现过，这样来做复杂度就为O(n) 
 ③我们需要设置的变量 
 输入：分子numerator 分母denominator 
 商 quotient 
 商的整数部分 integer 
 商的小数部分 digits[] 
 余数是否存在 reminder_exist[] 
 余数存在的位置 reminder_pos 
 商是否存在循环 found_cycle 
 商的小数部分开始循环的位置 cycle_pos 
 循环的长度 cycle_len 
 循环长度的限制 display_limit
 
算法思路
 
a）首先我们要表示商的小数点左边的部分，并且由于分子一直在变化，所以我们要设置一个新的变量保存下初始的分子，方便之后的输出
 
b）查找循环，由简单的数学知识可知，如果某两步计算的余数相等，那么他们之间的这些计算就是属于我们的循环小数了，所以我们需要就是找每步计算余数相等的，我们要知道他们分别的位置，这里我们采用两个数组来区分一个是reminder_exist[]这里保持，哪个余数存在，对应的值就为1，所以我们可以通过检测这个数组的值来找循环，之后因为我们还需要之前第一次出现这个循环的位置，所以我们还需要有一个数组保存第几次运算出现哪个余数。之后再用第二次出现计算次数减去第一次出现的次数，我们就可以得到循环节的长度了。而且每一步计算得到的商需要保存在一个数组中，这里命名为digits
 
c）最后再比较下计算最后一次与50进行比较，来按要求输出。 
 学习笔记：
 
本题最核心的算法在于，我们怎么去找出循环小数的循环体个数了，循环体初始位置和最后位置。
 
通过数学知识可以知道找余数相同的时候，每次计算得到的余数放在一个数组中，且数组对于位置为1，代表存在这个余数，之后再通过一个循环找这个位置为1的时刻，这就是余数相同的时候，并且用一个数组保存计算的次数，取每次计算得到的商保存在digits[]中，所以每次余数对应三个数组的值分别问商、计算次数、是否存在的。
 
//.c
#include <stdio.h>
#include <string.h>
#define maxn 100
#define display_limit 50
#define max_INT 10000

int digits[maxn];
int reminder_exist[max_INT];
int reminder_pos[max_INT];

int main()
{
    int numerator,denominator,quotient,reminder;
    while(scanf("%d%d", &numerator, &denominator) != EOF && denominator)
    {
        //初始化数组和商的整数部分
        int original_numerator = numerator;
        memset(reminder_exist, 0, sizeof(reminder_exist));
        memset(reminder_pos, 0, sizeof(reminder_pos));
        quotient = numerator/denominator;
        reminder = numerator%denominator;
        int integer = quotient;

        //找出循环
        int found_cycle = 0;
        int cycle_pos = maxn;
        int cycle_len = 0;
        int i = 0;

        for(i = 0; i <= maxn; i++)
        {
            if(reminder_exist[reminder])
            {
                cycle_pos = reminder_pos[reminder];
                cycle_len = i - cycle_pos;
                break;
            }
            else
            {
                reminder_exist[reminder] = 1; 
                reminder_pos[reminder] = i;
            }

            numerator = reminder * 10;
            quotient = numerator/denominator;
            reminder = numerator%denominator;

            digits[i] = quotient;
        }

        //输出
        printf("%d/%d = %d.(",original_numerator, denominator, integer);
        if(i <= display_limit)
        {
            for(int j = cycle_pos; j < i; j++)
            {
                printf("%d", digits[j]);
            }
        }
        else
        {
            for(int j = cycle_pos; j < display_limit;j++)
                printf("%d", digits[j]);
            printf("...");
        }
        printf(")\n");    
        printf("%d = number of digits in repeating cycle\n", cycle_len);
    }
    return 0;
}

 
原文：点击打开链接
 
1/7 = 0.142857142... 是个无限循环小数。 
 任何有理数都可以表示为无限循环小数的形式。 
  
 本题目要求即是：给出一个数字的循环小数表示法。 
  
 例如： 
 输入： 
 1,5 
 则输出： 
 0.2 
  
 输入： 
 1,7 
 则输出： 
 0.[142857] 
  
 输入： 
 7,6 
 则输出: 
 1.1[6] 
  
 用户输入的格式是： 
 整数,整数 
  
 每个整数范围均为：1~1000 
  
 
 
 
程序输出两个整数做除法产生的小数或无限循环小数（循环节用方括号括起）。
 
 

 
 
 
题目貌似不难，但却让人很难找到着手点，对于循环小数的判断，不知道大家有什么好的方法，这里，我讲一下我所使用的方法：余数检测法。
 
 

 
 
 
说白了，就是模拟除法的过程，比如我们要计算1/7这个小数的循环节，我们事先求出整数部分，也就是1/7=0。然后再求小数部分，求出第一组商con和它所对应的余数r，不难得出，con=（1×10）/7=1，r=（1×10）%7=3，如果想不明白，可以自己手算一下，然后进入循环，将第一组数据保存起来，接着算第二组，con=（3×10）/7=4，r=（3×10）%7=2。
 
 
每次求出一组商和余数的数据，我们需要判断一下：所求出的商之前有没有出现过，所求出的余数之前有没有出现过，只有商和余数同时出现在同一个位置，那就说明循环节出现了，然后我们记录循环节的位置pos，在之后把从0到pos之前的数据单独输出，这一部分是不循环的，然后从pos到最后的部分单独输出，这一部分是循环的。
 
 

 #include<iostream>
 
 #include<memory.h>
 
 #include<stdio.h>
 
 using namespace std;
 
 int pos;
 
 bool find(int *Rem,int *Dec,int r,int con,int q)
 
 {
 
         int i;
 
         for(i=0;i<q;i++)
 
         {
 
                 if(Rem[i]==r&&Dec[i]==con)//当余数和商都相等的时候，说明出现循环点
 
                 {
 
                         pos=i;//记录循环点的起始位置
 
                         return false;
 
                 }
 

         }
 
         return true;
 
 }
 

 void cal(int a,int b)
 
 {
 
         int i,j;
 
         int p=0;//Dec的指针
 
         int q=0;//Rem的指针
 
         int e=0;//结束的位置
 
         int Int,Dec[100],Rem[100],r,con;//Int整数部分，Dec小数部分，Rem余数部分，r临时余数，con临时商
 
         memset(Rem,0,sizeof(Rem));
 
         memset(Dec,0,sizeof(Dec));
 
         Int=a/b;
 
         if(a>=b)
 
                 a=a%b;
 

         con=a*10/b; //算出第一组余数和商
 
         r=(a*10)%b;
 

 
         while(find(Rem,Dec,r,con,q))
 
         {
 
                 Dec[p++]=con;
 
                 Rem[q++]=r;
 

                 r=r*10;//寻找之后的余数和商
 
                 con=r/b;
 
                 r=r%b;
 

         }
 

         cout<<Int<<'.';//输出整数部分
 
         for(i=0;i<pos;i++)//输出不循环的部分
 
                 cout<<Dec[i];
 

         for(i=99;i>=0;i--)//找到结束的位置
 
                 if(Dec[i]!=0)
 
                 {
 
                         e=i;
 
                         break;
 
                 }
 
         for(i=pos;i<e;i++)//从循环点到最后为循环的部分
 
         {
 
                if(i==pos)
 
                        cout<<"[";
 
                 cout<<Dec[i];
 
                 if(i==e-1)
 
                        cout<<"]";
 
         }
 
         cout<<endl;
 
 }
 

 int main()
 
 {
 

         int a,b;
 
         scanf("%d,%d",&a,&b);
 
         cal(a,b);
 
         return 0;
 
 }