写一个程序或函数，它在正整数a，b并c，并打印或返回a/b到c小数位，使用操作+ - * /％[加，减，乘，除，调制]在正整数：您可以使用所有您的语言允许，但不能使用浮点数。a，b，c的范围将是您语言中无符号整数所允许的范围。数字结果将被截断为最后一个要打印的数字（所以没有round）。

这意味着，如果您的语言没有整数类型（仅浮点数），则可以通过将这些浮点数仅用作正整数来参与。本练习的线索是编写仅在[无符号]整数上使用+-* /％运算来找到浮点数中的数字的函数。

例子

• print(1,2,1) 会打印 0.5
• print(1,2,2) 会打印 0.50
• print(13,7,27) 会打印 1.857142857142857142857142857
• print(2,3,1) 会打印 0.6
• print(4,5,7) 会打印 0.8000000
• print(4,5,1) 会打印 0.8
• print(9999,23,1) 会打印 434.7
• print(12345613,2321,89) 如果您的语言具有32位未签名，将打印 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

以字节为单位的最短代码获胜。如果这看起来不清楚，我很抱歉。测试一些与建议不同的输入。

05AB1E，17 13 11 19 14字节

以表格形式输入b, a, c。
多亏了Grimy节省了5个字节。

‰`¹+I°*¹÷¦'.sJ

在线尝试！

Haskell，87个字节

(a#b)c|s<-show$div(a*10^c)b,l<-length s-c,(h,t)<-splitAt l s=['0'|l<1]++h++['.'|c>0]++t

用法示例：(13#7)27-> "1.857142857142857142857142857"。

23个字节来处理c==0情况，并使用前导零代替.5。

工作原理：a与10^c乘除，除以b，转换为字符串，在.必须插入的位置进行分割，将两者.之间插入并固定边缘盒。

Perl 6的， 58个57 55  48字节

{(($^a.FatRat/$^b*10**$^c).Int.FatRat/10**$c).base(10,$c)}

{(Int($^a.FatRat/$^b*10**$^c).FatRat/10**$c).base(10,$c)}

{base Int($^a.FatRat/$^b*10**$^c).FatRat/10**$c: 10,$c}

{base ($^a*10**$^c div$^b).FatRat/10**$c: 10,$c}

相当令人讨厌的是，可以将其缩短为仅{($^a.FatRat/$^b).base(10,$^c)}允许四舍五入到最接近的值。

说明：

# bare block lambda with 3 placeholder parameters ｢$^a｣, ｢$^b｣ and ｢$^c｣
{
  (
    (

      # create an Int containing all of the digits we care about
      $^a * 10 ** $^c div $^b

    ).FatRat / 10**$c  # turn it into a Rational

  ).base( 10, $c )     # force it to display ｢$c｣ digits after the decimal point
}

Perl，55个字节

包括+3 -p

在STDIN的一行上给出a和b，在下一行给出c

division.pl
1 26
38
^D

division.pl：

#!/usr/bin/perl -p
eval'$\.=($_/$&|0)."."x!$\;$_=$_%$&.0;'x(/ .*/+<>)}{

这$_/$&有点争论。我实际上想要在那里进行整数除法，但是perl在不加载特殊模块的情况下就没有这种除法。因此，它暂时是一个非整数，然后我立即将其截断（使用|0），因此最终得到整数除法给出的整数。可以将其重写为($_-$_%$&)/$&甚至暂时不具有非整数值（尽管在内部仍然是浮点数）

JavaScript（ES6），55 50字节

f=(a,b,c,d=".")=>~c?(a/b|0)+d+f(a%b*10,b,c-1,""):d

(a/b|0)执行浮点除法，但立即转换为整数。如果不允许这样做，请告诉我。

PHP，187字节

使用分子的字符串，其整数值可以大于 PHP_INT_MAX

list(,$n,$d,$c)=$argv;$a=str_split($n);while($a){$n.=array_shift($a);if($n>=$d||$r)$n-=$d*$r[]=$n/$d^0;}if(!$r)$r[]=0;if($c)$r[]=".";while($c--){$n*=10;$n-=$d*$r[]=$n/$d^0;}echo join($r);

我没有其他机会，然后13/7缩短为1.8571428571429而我达到了，所以不是测试用例有27个小数位

这样不允许36个字节

<?=bcdiv(($z=$argv)[1],$z[2],$z[3]);

Pyth- 21 19 18 16 14字节

将查看输入格式，可以节省很多。

j\.c`/*E^TQE]_

测试套件。（PS 27尚未在线完成，所以我改为10。）

JavaScript（ES6）， 64  62 59字节

由于ETHproductions，节省了2个字节。

所包含的除法总是得出整数。

f=(a,b,n,s)=>~n?f((q=(a-a%b)/b,a%b*10),b,n-1,s?s+q:q+'.'):s

console.log(f(13,7,27))

Java 7，105字节

import java.math.*;String c(int...a){return new BigDecimal(a[0]).divide(new BigDecimal(a[1]),a[2],3)+"";}

取消测试代码：

在这里尝试。

import java.math.*;
class M{
  static String c(int... a){
    return new BigDecimal(a[0]).divide(new BigDecimal(a[1]), a[2], 3)+"";
  }

  public static void main(String[] a){
    System.out.println(c(1, 2, 1));
    System.out.println(c(1, 2, 2));
    System.out.println(c(13, 7, 27));
    System.out.println(c(2, 3, 1));
    System.out.println(c(4, 5, 7));
    System.out.println(c(4, 5, 0));
    System.out.println(c(9999, 23, 0));
    System.out.println(c(12345613, 2321, 89));
  }
}

输出：

0.5
0.50
1.857142857142857142857142857
0.6
0.8000000
0
434
5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Ruby，67个字节

->(a,b,c){('0'+(a*10**c/b).to_s).gsub(/^0*(.+)(.{#{c}})$/,'\1.\2')}

如果我执行上面的测试用例的功能

def print(a,b,c); ('0'+(a*10**c/b).to_s).gsub(/^0*(.+)(.{#{c}})$/, '\1.\2'); end
 => :print 
print(1,2,1)   # would print 0.5
 => "0.5" 
print(1,2,2)   # would print 0.50
 => "0.50" 
print(13,7,27) # would print 1.857142857142857142857142857
 => "1.857142857142857142857142857" 
print(2,3,1)   # would print 0.6
 => "0.6" 
print(4,5,7)   # would print 0.8000000
 => "0.8000000" 
print(4,5,1)   # would print 0.8
 => "0.8" 
print(9999,23,1) # would print 434.7
 => "434.7" 
print(12345613,2321,89) # would print if your Language has 32 bit unsigned 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466
 => "5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466" 
"('0'+(a*10**c/b).to_s).gsub(/^0*(.+)(.{#{c}})$/, '\1.\2')".length
 => 52 

拍子203字节

(let*((s(~r(/ a b)#:precision c))(sl(string-split s "."))(s2(list-ref sl 1))(n(string-length s2)))
(if(< n c)(begin(for((i(- c n)))(set! s2(string-append s2 "0")))(string-append(list-ref sl 0)"."s2))s))

取消高尔夫：

(define (f a b c)
  (let* ((s (~r(/ a b)#:precision c))
         (sl (string-split s "."))
         (s2 (list-ref sl 1))
         (n (string-length s2)))
    (if (< n c)
        (begin 
          (for ((i (- c n)))
            (set! s2 (string-append s2 "0")))
          (string-append (list-ref sl 0) "." s2))
        s )))

用法：

(f 7 5 3)
(f 1 2 1) 
(f 1 2 2) 
(f 13 7 27)

输出：

"1.400"
"0.5"
"0.50"
"1.857142857142857142857142857"

其他方法（此处无效答案）：

(real->decimal-string(/ a b)c)

q，196字节

w:{((x 0)div 10;1+x 1)}/[{0<x 0};(a;0)]1;{s:x 0;m:x 2;r:(10*x 1)+$[m<0;{x*10}/[-1*m;a];{x div 10}/[m;a]]mod 10;d:1#.Q.s r div b;($[m=-1;s,".",d;$[s~,:'["0"];d;s,d]];r mod b;m-1)}/[c+w;("";0;w-1)]0

运行：首先设置a，b，c。

锈，114字节

fn print(mut a:u32,b:u32,c:u32){let mut p=||{print!("{}",a/b);a=a%b*10};p();if c>0{print!(".")}for _ in 0..c{p()}}

测试代码：

fn main() {
    print(1, 2, 1);    println!(""); // should print 0.5
    print(1, 2, 2);    println!(""); // should print 0.50
    print(13, 7, 27);  println!(""); // should print 1.857142857142857142857142857
    print(2, 3, 1);    println!(""); // should print 0.6
    print(4, 5, 7);    println!(""); // should print 0.8000000
    print(4, 5, 0);    println!(""); // should print 0
    print(9999, 23, 0);println!(""); // should print 434
    print(12345613,2321,89); println!("\n");  // 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466
}

PHP，89字节

list(,$a,$b,$c)=$argv;for($o=intdiv($a,$b).'.';$c--;)$o.=intdiv($a=10*($a%$b),$b);echo$o;

intdiv（）是php 7中引入的，因此需要这样做。PHP 7.1将允许我将list（）更改为[]，因此将节省4个字节。

用途像：

php -r "list(,$a,$b,$c)=$argv;for($o=intdiv($a,$b).'.';$c--;)$o.=intdiv($a=10*($a%$b),$b);echo$o;" 1 2 1

C＃，126个字节

(a,b,c)=>{var v=a*BigInteger.Parse("1"+new string('0',c))/b+"";return v.PadLeft(c+1,'0').Insert(Math.Max(1,v.Length-c),".");};

完整的测试用例程序：

using System;
using System.Numerics;

namespace DivisionOfNotSoLittleNumbers
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<BigInteger,BigInteger,int,string>f= (a,b,c)=>{var v=a*BigInteger.Parse("1"+new string('0',c))/b+"";return v.PadLeft(c+1,'0').Insert(Math.Max(1,v.Length-c),".");};

            //test cases:
            Console.WriteLine(f(1,2,1));    //0.5
            Console.WriteLine(f(1,2,2));    //0.50
            Console.WriteLine(f(13,7,27));  //1.857142857142857142857142857
            Console.WriteLine(f(2,3,1));    //0.6
            Console.WriteLine(f(4,5,7));    //0.8000000
            Console.WriteLine(f(4,5,1));    //0.8
            Console.WriteLine(f(9999,23,1));    //434.7
            Console.WriteLine(f(12345613,2321,89)); //5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466
            Console.WriteLine(f(2,3,1));    //0.6
            Console.WriteLine(f(4,5,2));    //0.80
        }
    }
}

实现整数除法。由于BigInteger数据类型（System.Numerics需要导入），可以使用任何大小的数字。digit-count参数c限制为2 ^ 31-1，但是应该提供足够多的数字。

Groovy（78 77 42字节）

{a,b,n->Eval.me(a+'.0g').divide(b, n, 1)}​

说明

Eval.me(a+'.0g');-从整数输入转换为BigDecimal输入。在Groovy中，BigDecimal表示法是带有附加G或g的双重表示法。我也可以使用构造函数，new BigDecimal(it)但这节省了一个字节。
.divide(b, n, 1)-以n精度除以b，四舍五入取整模式。

在这里尝试：https : //groovyconsole.appspot.com/script/5177545091710976

批处理，122字节

@set/as=%1/%2,r=%1%%%2
@set s=%s%.
@for /l %%a in (1,1,%3)do @set/ad=r*10/%2,r=r*10%%%2&call set s=%%s%%%%d%%
@echo %s%

Mathematica，50个字节

StringInsert[ToString@Floor[10^# #2/#3],".",-#-1]&

的三个参数（这是有序的无名功能c，a，b以节省一个字节的地方），并返回一个字符串。它乘以a/b通过10^c，需要最大的整数函数，然后转换为字符串，并插入在适当的点小数点。不幸的是，函数名称并不短。

Python 3，62个字节

a,b,c=map(int,input().split());print("{:.{1}f}".format(a/b,c))

在这里尝试

*注意：repl.it使用较旧的Python 3版本，该版本要求指定所有字段索引，这意味着"{:.{1}f}"将其"{0:.{1}f}"替换为repl.it中的63个字节

如何使用

输入所有三个值，中间使用空格。即的输入1 2 1将得出结果0.5

说明

input().split()：获取用户输入并将其分割为带有（空格）分隔符的列表

a,b,c = map(int,XX)：将变量映射为用户使用int类型指定的值

"{:.{1}f}".format(a/b,c)：格式化字符串以显示除法结果并替换{1}为c设置小数位所显示的字符串的

print(XX)：打印提供的字符串

Python 3，58字节

lambda a,b,c:(lambda s:s[:-c]+"."+s[-c:])(str(a*10**c//b))

在线尝试！

只要指定的小数位数精确到 a * 10 ** c不是太大，。

我尝试将Python 2缩短到str(...)，`...`但是如果Python 2 L太大，则会在末尾插入，因此检查该字节将花费更多的字节数。

Stax，13 个字节

ä·oαì█↕▬AS¥é▼

运行并调试

c a b顺序接受参数。

C，67字节

h(a,b,i){int j=!i;for(;printf(j++?"%u":"%u.",a/b),i--;a=10*(a%b));}

在线尝试！

我认为某些以前的版本在读取内存中存在错误，超出了分配给程序的权限...感谢ceilingcat和所有人...