算法思路

定理：一个分母为N的循环小数的循环节位数最多不超过N-1位
若A/B为无限循环小数的话，则在出现循环节之前，每次长除法的余数都不相同

代码
/**
* @param a 分子
* @param b 分母
* @return  返回代表循环节的字符串
*/
static String getRepetend(int a,int b){
	String decimal ="";
	List<Integer> temp = new LinkedList<Integer>();
	a = a%b;
	loop:
	while(a!=0){
		if(!temp.contains(a))	temp.add(a);
		else
			for(int i=0;i<temp.size();i++)
				if(temp.get(i)==a) {
					decimal = decimal.substring(i,decimal.length());
					break loop;
				}
		decimal += a*10/b;
		a = (a*10)%b;
	}
	return decimal;
}

算法例子
参考：https://programtip.com/zh/art-111488

给定分子a，分母b，若a除以b为无限循环小数，则输出格式为整数部分.小数部分[循环节]，例如1.03333333输出格式为1.0[3]，若是有限小数，则输出不带后缀零的结果，例如1.25输出格式为1.25

代码
import java.util.LinkedList;
import java.util.List;
public class test {
	
	static String getResult(int a,int b){
		if(a%b==0)	return String.valueOf(a/b);
		String decimal ="";
		List<Integer> temp = new LinkedList<Integer>();
		a = a%b;
		loop:
		while(a!=0){
			if(!temp.contains(a))	temp.add(a);
			else
				for(int i=0;i<temp.size();i++)
					if(temp.get(i)==a) {
						decimal = decimal.substring(0,i)+"["+decimal.substring(i,decimal.length())+"]";
						break loop;
					}
			decimal += a*10/b;
			a = (a*10)%b;
		}
		return String.valueOf(a/b)+"."+decimal;
	}
	
	public static void main(String[] args) {
		for(int i=1; i<=20; i++)
			System.out.println(getResult(1,i));
	}
}

结果
1
0.5
0.[3]
0.25
0.2
0.1[6]
0.[142857]
0.125
0.[1]
0.1
0.[09]
0.08[3]
0.[076923]
0.0[714285]
0.0[6]
0.0625
0.[0588235294117647]
0.0[5]
0.[052631578947368421]
0.05

循环节： 

    如果无限小数的小数点后，从某一位起向右进行到某一位止的一节数字循环出现，首尾衔接，称这种小数为循环小数，这一节数字称为循环节。 

    #寻找1000以内的n，使得1/n的循环小数节长度最长



#问题化简，首先不是素数的数的循环节长度必定可以由其他数组成比如14可以由2*7组成，
#那么1/14与1/7有相同的循环节长度，所以只需找出所有的素数不（包括2与5），求的他们的循环节长度。
#判断一个1/n是否为循环小数。
def zhi(n):
    if n==2 or n==5:
        return True
    if n%2==0:
        return zhi(n//2)
    if n%5==0:
        return zhi(n//5)
    return False
   #判断一个数n是否为素数
def is_prime(n):
    if n == 1:
        return False
    for i in range(2, int(sqrt(n))+1):
        if n % i == 0:
            return 

前提是所有的数必须是质数（即素数）循环节的长度是使分母P整除10^k-1的最小k值。例如：9可以整除10^1-1,所以当分母为9时，循环节是1位。7可以整除10^6-1=999999,所以当分母为7时，循环节是6位。



#判断1/n的小数循环节点长度
 Length(n):
    L=1
    while(True):
        if (10**L-1)%n==0:
            break
        L+=1
    return L



a=[]
for i in range(2,101):
    if is_prime(i) and i!=2 and i!=5:#素数包括2与5
        a.append([Length(i),i])
print(a)
##[[1, 3], [6, 7], [2, 11], [6, 13], [16, 17], [18, 19], [22, 23], [28, 29], [15, 31], [3, 37], [5, 41], [21, 43], [46, 47], [13, 53], [58, 59], [60, 61], [33, 67], [35, 71], [8, 73], [13, 79], [41, 83], [44, 89], [96, 97]]

第一次知道利用上面的算法来求循环节，真是长见识了。继续努力。

    
问题：
　　输入整数a和b，输出a/b的循环小数表示以及其循环节长度。例如 a=5 b=43 小数表示为0.（116279069767441860465），循环节长度为21；
 
分析： 
　　长除法的计算过程
 
　　　　①mod = a%b；
 
　　　　②小数 = （mod*10） / b；
 
　　　　③mod = （mod*10）%b；
 
　　循环②③步，当出现重复的余数的时候，也就是循环节出现了
注意事项：
　　当循环上述2、3步骤时，出现余数为零的情况，即计算结果不是循环小数时，直接输出索引值，循环节长度为0。
 
C++实现：

 1 #include<iostream>
 2 using namespace std;
 3 
 4 int main() {
 5     int a, b, t, k;
 6     cin >> a >> b;
 7     int index = 0;
 8     t = a%b;
 9     if (t ==0) {
10         cout << index << " " << index << endl;
11         return 0;
12     }
13     int flag[10000] = {0};
14     memset(flag,-1,1000);
15     k =0;
16     int length = 0;
17     while (true) {
18         t = (t*10)%b;
19         if (t == 0) {
20             index = ++k;
21             length = 0;
22             break;
23         }
24 
25         if(flag[t] >= 0) {
26             index = flag[t];
27             length = k - index;
28             break;
29         }
30         flag[t]=k;
31         k++;
32     }
33 
34     cout << index << " " << length << endl;
35     return 0;
36 }

 
 
　　　　

转载于:https://www.cnblogs.com/TonvyLeeBlogs/p/9563915.html

输入整数a和b（0<=a<=3000,1<=b<=3000),输出a/b的循环小数表示以及循环节长度。例如a=5,b=43,小数表示为
0.(116279069767441860465),循环节长度为21；  
思路:分数不能表示无限不循环小数。建立3个数组，一个放商，一个放余数，一个对应下角标的数若是余数则元素为1，即记录余数存在。循环除数加一次，若余数为0，则循环节长度为1，若当前得到的余数已经存在，则有循环节，求出2个相同余数的距离即为循环节长度。

  这个主要是怎么寻找循环节，在除法计算的过程中如何判断一个循环节已经出现了。循环节第二次出现意味着计算过程中的余数已经第二次出现。其实自己在草纸上写一个比如5/7就能发现。当商5的时候（5是循环节的最后一位）余数是5，这和第一次商0的时候（0是循环节前一位）余数也是五。然后用索引存储是否这个余数已经出现过，还有一个数组记录余数对应的商的位置。余数的范围是1~m-1，所以循环节最长是m-1，所以查询数组的大小根据m的值来设定




#include <iostream>  

#include <cstdlib>  

#include <cstring>  

#include <cstdio>  

  

using namespace std;  

  

int r[3003],u[3003],s[3003];  

  

int main()  

{  

    int n,m,t;  

    while (cin >> n >> m) {  

        t = n;  

        memset(r, 0, sizeof(r));  

        memset(u, 0, sizeof(u));  

        int count = 0;  

        r[count ++] = n/m;  

        n = n%m;  

        while (!u[n] && n) {  

            u[n] = count;  

            s[count] = n;  

            r[count ++] = 10*n/m;  

            n = 10*n%m;  

        }  

        printf("%d/%d = %d",t,m,r[0]);  

        printf(".");  

        for (int i = 1 ; i < count && i <= 50 ; ++ i) {  

            if (n && s[i] == n) printf("(");  

            printf("%d",r[i]);  

        }  

        if (!n) printf("(0");  

        if (count > 50) printf("...");  

        printf(")\n");  

        printf("   %d = number of digits in repeating cycle\n\n",!n?1:count-u[n]);  

    }  

    return 0;  

}