DouKaku?

fun! Frac(a, b)
  let a = a:a
  let b = a:b
  let i = 0
  let col = range(1, b*b)
  let col[0] = 0
  let col[b] = 0
  let s = (a / b) . "."
  while 1
    let i = i + 1
    let a = a % b
    let col[b+i] = a
    let j = col[a]
    if j >= 0 && j < i && col[b+j] == a
      break
    endif
    let col[a] = i
    let a = a * 10
    let s .= (a / b)
  endwhile
  if a == 0
    return s
  endif
  if col[a] == (i-1)
    let i = 1
  endif
  let s = strpart(s, 0, col[a]+1) . "{" . strpart(s, col[a]+1, i) . "}"
  return s
endfun

def modulo(numerator, denominator):
    while numerator:
        div, numerator = numerator // denominator, numerator % denominator
        yield div, numerator
        numerator *= 10

def recurring_decimal(numerator, denominator):
    result = []
    reminds = {}
    for u, r in enumerate(modulo(numerator, denominator)):
        result.append(str(r[0]))
        if r[1] in reminds:
            # 循環有り
            idx = reminds[r[1]]+1
            return '%s.%s{%s}' % (result[0], ''.join(result[1:idx]), ''.join(result[idx:]))
        reminds[r[1]] = u
    # 循環無し
    if len(result)==1:
        return result[0]
    else:
        return '%s.%s' % (result[0], ''.join(result[1:]))

(use text.tree)

(define (div a b)
  (tree->string `("0." ,(div2 (* a 10) b (make-hash-table 'eqv?)))))

(define (div2 a b h)
  (cond ((hash-table-get h a #f)
         => (lambda (x)
              (set-car! x `("{" ,(car x)))
              `("}")))
        (else
          (call-with-values
            (cut quotient&remainder a b)
            (lambda (q r)
              (if (zero? r) `(,q)
                  (let1 p (cons q #f)
                    (hash-table-put! h a p)
                    (set-cdr! p (div2 (* r 10) b h))
                    p)))))))

(print (div 3 8))
(print (div 3 14))

require 'rational'

def func(a, b)
  c = a / b
  dst = ["#{c}."]
  d = [0, Rational(a, b) - c]
  h = []
  1.upto(10) {|i|
    d = d[1].divmod(Rational(1, 10 ** i))
    k = [d[0], d[1].numerator, d[1].denominator / 10 ** i]
    if k == [0, 0, 0]
      return dst.to_s
    end
    if n = h.index(k)
      return (dst[0..n] + ["{"] + dst[n + 1..dst.size] + ["}"]).to_s
    end
    h << k
    dst << d[0]
  }
  dst.to_s + "..."
end

def flac_to_decimal(a,b)
  r = '0.'
  m = []
  while a != 0
    m << a
    a *= 10
    r += "#{a/b}"
    if i = m.index(a%=b)
      r[i+2,0] = '{'
      r += '}'
      break
    end
  end
  r
end

<?php
function decimal($numerator, $denominator){
	$remainders = array();
	$fraction = array();
	$remainder = $numerator % $denominator;
	while(!(in_array($remainder, $remainders) || $remainder == 0)){
		$numerator = $remainder * 10;
		$quotient = floor($numerator / $denominator);
		$remainders[] = $remainder;
		$fraction[]= $quotient;
		$remainder = $numerator % $denominator;
	}
	if(!(floor($remainder * 10 / $denominator) == 0 && $remainder == 0)){
		$loop_start = array_search($remainder, $remainders);
		$fraction[$loop_start] = '{'.$fraction[$loop_start];
		$fraction[] = '}';
	}
	return '0.'.join('',$fraction);
}
echo(decimal(3, 14));
?>

(defun %rational->decimal-calc (rat)
  (let ((a (numerator rat))
        (b (denominator rat))
        ret mods)
    (loop
       do
         (setf a (* 10 a))
         (push (floor (/ a b)) ret)
         (setf a (mod a b))
       until
         (or (zerop a) (member a mods))
       do
         (push a mods)
       finally
         (setf ret (nreverse ret)))
    (if (zerop a)
        ret
        (nconc (insert ret (position (floor (/ (* 10 a) b)) ret :from-end t) "{") '("}")))))

(defun insert (list n newelt)
  `(,@(butlast list (- (length list) n)) ,newelt ,@(nthcdr n list)))

(defun rational->decimal (rat)
  (multiple-value-bind (int frac) (truncate rat)
    (format nil "~a.~{~a~}" int (%rational->decimal-calc frac))))

/**
 * 
 * @param dividend (a) 被除数
 * @param divisor (b) 除数
 * @return 商
 */
public static String getResult(final int dividend, final int divisor) {
    return generateResultString(getDigits(dividend, divisor));
}

private static List<Integer> getDigits(final int dividend, final int divisor) {

    final List<Integer> dividends = new LinkedList<Integer>();
    final List<Integer> digits = new LinkedList<Integer>();

    getDigits(dividend, divisor, digits, dividends);
    return digits;
}

private static void getDigits(final int dividend, final int divisor,
        final List<Integer> digits, final List<Integer> dividends) {

    final int containedIndex = dividends.indexOf(Integer.valueOf(dividend));
    if (containedIndex >= 0) {
        digits.add(Integer.valueOf(containedIndex - digits.size()));
        return;
    }

    digits.add(Integer.valueOf(dividend / divisor));

    final int remainder = dividend % divisor;
    if (remainder != 0) {
        dividends.add(Integer.valueOf(dividend));
        getDigits(remainder * 10, divisor, digits, dividends);

    }
}

private static String generateResultString(final List<Integer> digits) {
    
    final StringBuilder sb = new StringBuilder();
    assert digits.size() > 0;
    sb.append(digits.get(0));
    
    if (digits.size() > 1) {
        sb.append(".");
        for (final Iterator<Integer> itr = digits.listIterator(1); itr.hasNext();) {
            final int digit = itr.next().intValue();
            if (digit >= 0) {
                sb.append(digit);
            } else {
                sb.insert(sb.length() + digit, "{");
                sb.append("}");
            }
        }
    }
    return sb.toString();
}

let find_index_of e l =
  try
    let (i, _) = List.findi (fun i' e' -> e = e') l in Some i
  with Not_found -> None

let decimal_of_frac a b = 
  let rec decimal_of_frac' a quots rems =
    let quot = a / b and rem = a mod b in
    match find_index_of (a mod b) rems with
    | Some i -> (quot::quots, i)
    | None   -> decimal_of_frac' (rem * 10) (quot::quots) (rem::rems)
  in
  decimal_of_frac' a [] []

let pretty_fmt (numbers, i) =
  let loop = List.rev (List.take (i + 1) numbers) in
  let d::ds = List.rev (List.drop (i + 1) numbers) in
  let string_of_nums ns = String.concat "" (List.map string_of_int ns) in
  (string_of_int d) ^ "." ^ (string_of_nums ds) ^ 
    if loop = [0] then "" else "{" ^ (string_of_nums loop) ^ "}"

import java.util.Map;
import java.util.HashMap;

public class Fraction {
	
	public static String toRepeatingDecimal(int numerator, int denominator) {
		Map<Integer, Integer> remainders = new HashMap<Integer, Integer>();
		long d, q, r;
		int i = 0;
		StringBuffer sb = new StringBuffer();
		d = denominator;
		r = numerator;
		q = r / d;
		r = r % d;
		remainders.put((int)r, i++);
		r *= 10;
		sb.append(q);
		if (r > 0) {
			sb.append('.');
			do {
				q = r / d;
				r = r % d;
				sb.append(q);
				Integer index = remainders.get((int)r);
				if (index != null) {
					sb.insert(sb.length() - i + index, '{');
					sb.append('}');
					break;
				}
				remainders.put((int)r, i++);
				r *= 10;
			} while (r > 0);
		}
		return sb.toString();
	}
	
}

public static String getDecimal(long a, long b) {
    java.util.Vector<Long> nums = new java.util.Vector<Long>();
    StringBuffer res = new StringBuffer("0.");
    while (true) {
        nums.add(a);
        a *= 10;
        res.append(a/b);
        a %= b;
        if (a == 0) {
            return res.toString();
        }
        if (nums.contains(a)) {
            int off = nums.indexOf(a) + 2;
            return res.substring(0,off) + "{" + res.substring(off) + "}";
        }
    }
}

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

int cal(char *ans, size_t<