Escriba un programa o función que tome enteros positivos a, by c, e imprima o regrese a/ba clugares decimales, usando las operaciones + - * /% [sumar, restar, multiplicar, dividir, modular] en los enteros positivos: puede usar todo eso su idioma lo permite, pero no en números de coma flotante. El rango de a, b, c sería el rango permitido para enteros sin signo en su idioma. El resultado del número se truncará hasta el último dígito para imprimir (por lo tanto, no round).

Esto significa que si su idioma no tiene un tipo entero (solo flotante), puede participar utilizando estos números flotantes solo como enteros positivos. La clave de este ejercicio sería escribir la función que encuentra los dígitos en una división de coma flotante, utilizando solo la operación + - * /% en enteros [sin signo].

Ejemplos

• print(1,2,1) imprimiría 0.5
• print(1,2,2) imprimiría 0.50
• print(13,7,27) imprimiría 1.857142857142857142857142857
• print(2,3,1) imprimiría 0.6
• print(4,5,7) imprimiría 0.8000000
• print(4,5,1) imprimiría 0.8
• print(9999,23,1) imprimiría 434.7
• print(12345613,2321,89) se imprimiría si su idioma tiene 32 bits sin signo 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

El código más corto en bytes gana. Lo siento si esto no parece claro ... No sé los idiomas también, no recuerdo bien las palabras ... Es mejor tener un enlace a Ideone.com o algún otro lugar para probar fácilmente la respuesta especialmente para prueba alguna entrada diferente de la propuesta.

05AB1E , 17 13 11 19 14 bytes

Entrada en el formulario b, a, c.
Guardado 5 bytes gracias a Grimy .

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

Pruébalo en línea!

Haskell, 87 bytes

(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

Ejemplo de uso: (13#7)27-> "1.857142857142857142857142857".

23 bytes para manejar el c==0caso y usar un cero inicial en lugar de cosas como .5.

Cómo funciona: multiplique acon 10^c, divida por b, convierta en una cadena, divida donde .debe insertarse, una ambas partes con un punto .intermedio y arregle los casos de borde.

Perl 6 ,  58 57 55  48 bytes

{(($^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}

Lo que es bastante molesto es que podría acortarse a solo {($^a.FatRat/$^b).base(10,$^c)}si se le permitiera redondear al valor más cercano.

Explicación:

# 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 bytes

Incluye +3 para -p

Dé ayb en una línea en STDIN, c en la siguiente

division.pl
1 26
38
^D

division.pl:

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

El $_/$&es un poco discutible. Realmente quiero una división entera allí, pero Perl no tiene eso sin cargar módulos especiales. Entonces, es temporalmente un no entero que luego trunco ​​inmediatamente (usando |0), así que termino con el entero que daría una división entera. Podría reescribirse ($_-$_%$&)/$&para no tener siquiera temporalmente un valor no entero (aunque internamente seguiría siendo flotante)

JavaScript (ES6), 55 50 bytes

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

(a/b|0)realiza la división flotante pero inmediatamente se convierte en un entero. Avísame si esto no está permitido.

PHP, 187 bytes

funciona con cadenas para el numerador que pueden ser valores int mayores que 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);

No tengo otra oportunidad, entonces 13/7 se acorta a 1.8571428571429 y no alcanzo el caso de prueba con 27 decimales

De esta manera, 36 Bytes no están permitidos

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

Pyth - 21 19 18 16 14 bytes

Examinará el formato de entrada, que puede ahorrar muchísimo.

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

Test Suite . (PS 27 no termina en línea, así que hice 10 en su lugar).

JavaScript (ES6),  64  62 59 bytes

Ahorró 2 bytes gracias a ETHproductions.

La división incluida siempre da como resultado un número entero.

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 bytes

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

Ungolfed y código de prueba:

Pruébalo aquí.

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));
  }
}

Salida:

0.5
0.50
1.857142857142857142857142857
0.6
0.8000000
0
434
5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Ruby, 67 bytes

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

si hago una función para ejecutar los casos de prueba anteriores

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 

Raqueta 203 bytes

(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))

Sin golf:

(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 )))

Uso:

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

Salida:

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

Otro método (respuesta no válida aquí):

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

q, 196 bytes

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

Para ejecutar: establezca a, b, c primero.

Óxido, 114 bytes

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()}}

código de prueba:

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 bytes

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

intdiv () se introduce en php 7, por lo que requiere eso. php 7.1 me permitiría cambiar la lista () a [] y así ahorraría 4 bytes.

usar como:

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 bytes

(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),".");};

Programa completo con casos de prueba:

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
        }
    }
}

Se implementa la división de enteros. Se pueden usar números de cualquier tamaño, debido al BigIntegertipo de datos ( System.Numericsse requiere la importación ). El parámetro de recuento de dígitos cestá restringido a 2 ^ 31-1, sin embargo, debe proporcionar dígitos más que suficientes.

Groovy ( 78 77 42 Bytes)

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

Explicación

Eval.me(a+'.0g');- Convertir de entrada entera a entrada BigDecimal. En groovy, la notación BigDecimal es doble con una G o g adjunta. También podría haber usado el constructor, new BigDecimal(it)pero esto salvó un byte.
.divide(b, n, 1)- Dividir por b con n precisión, redondeando a la mitad.

Pruébelo aquí: https://groovyconsole.appspot.com/script/5177545091710976

Lote, 122 bytes

@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 bytes

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

Función sin nombre de los tres argumentos (que están ordenados c, a, bpara guardar un byte de alguna parte), que devuelve una cadena. Se multiplica a/bpor 10^c, toma la función entera más grande, luego se convierte en una cadena e inserta un punto decimal en el lugar apropiado. Lástima que los nombres de las funciones no sean más cortos.

Python 3, 62 Bytes

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

Pruébalo aquí

* Nota : repl.it usa una versión anterior de Python 3 , que requiere que se especifiquen todos los índices de campo, lo "{:.{1}f}"que significa que en su "{0:.{1}f}"lugar será 63 bytes en repl.it

Cómo utilizar

Ingrese los tres valores con espacios intermedios. es decir, una entrada de 1 2 1daría un resultado de0.5

Explicación

input().split(): Obtiene la entrada del usuario y la divide en una lista con un separador de (espacio)

a,b,c = map(int,XX): Asigna las variables a los valores especificados por el usuario con un tipo int

"{:.{1}f}".format(a/b,c): Formatea una cadena para mostrar el resultado de la división y la sustituye {1}porc para ajustar la posición decimal de la cadena mostrada

print(XX): imprime la cadena suministrada

Python 3 , 58 bytes

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

Pruébalo en línea!

Esto es preciso para el número especificado de decimales siempre que a * 10 ** c no sea demasiado grande.

Intenté Python 2 para acortar el str(...)to `...`pero Python 2 inserta un Lal final si es demasiado grande, por lo que verificar eso tomaría más bytes de lo que vale.

Stax , 13 bytes

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

Ejecutar y depurarlo

Los argumentos son aceptados en c a borden.

C, 67 bytes

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

Pruébalo en línea!

Creo que alguna versión anterior tenía un error en la memoria de lectura asignada al programa ... Gracias a ceilingcat y por todo ...