Implemente una función divide(int a, int b, int c)que imprima el valor base 10 de a/b. sin utilizar ningún cálculos de coma flotante ni BigInteger/ BigDecimalo bibliotecas equivalentes de ningún tipo. Se deben imprimir al menos ccaracteres precisos dentro del conjunto de 0123456789., excepto la (posible) excepción en el punto 4 a continuación.

1. ay bpuede ser cualquier número entero de 32 bits. Actualización: si, para fines de golf, desea que la entrada sea primitiva de 64 bits, está bien, pero no necesita admitir todo el rango de datos de 64 bits.
2. No necesita verificar que csea ​​positivo (aunque es de esperar que su programa no se bloquee) si no lo es.
3. El límite superior mínimo admitido para ces 500. Está bien si su programa no admite valores de carriba 500, pero también está bien si lo hace.
4. Para números que se dividen en partes iguales, usted elige si desea imprimir ceros adicionales (según el valor de c) o nada.
5. No necesita poder utilizar la función para realizar otras tareas con el cociente, el único objetivo es imprimir.
6. Para los números entre -1y 1, es su elección si imprime un encabezado 0. Sin embargo, este es el único escenario donde la impresión de un cero inicial es aceptable, y solo puede imprimir uno de esos cero.
7. Puede usar cualquier lógica de redondeo / piso / techo que prefiera para el último decimal.
8. Para una respuesta negativa, debe imprimir un encabezado -. Esto no cuenta para c. Sin embargo, es su elección si desea imprimir , +o nada por una respuesta positiva.
9. La división entera y el módulo entero están permitidos. Sin embargo, tenga en cuenta que está restringido a primitivas, a menos que elija implementar su propia BigInteger/ BigDecimalbiblioteca que cuenta en función de la longitud de su código.
10. No necesita manejar el bser 0, aunque puede hacerlo si lo desea. Su programa puede entrar en un bucle infinito o bloquearse si b=0no será penalizado.
11. Ligero cambio de regla por comentario. Para asegurarse de que el campo de juego esté nivelado ay bgarantizado que sean enteros de 32 bits, puede usar enteros de 64 bits. Si su idioma elegido va más allá de los enteros de 64 bits como primitivo, en ningún momento puede usar esa funcionalidad (pretenda que tiene un límite de 64 bits).
12. Otro punto que no está claro (sin embargo, no debería cambiar ninguna de las respuestas válidas actuales): aunque cpuede interpretarse como el número de caracteres impresos o el número de espacios después del decimal, su programa debe usar de calguna manera relevante para decidir cuántos caracteres imprimir. En otras palabras, divide(2,3,2)debería ser un resultado mucho más corto que divide(2,3,500); no está bien imprimir 500 caracteres sin tener en cuenta c.
13. En realidad no me importa el nombre de la función. dEstá bien para fines de golf.

Entrada

stdinSe aceptan tanto una llamada de función como la lectura de . Si lees stdin, cualquier carácter que no esté en el conjunto [-0123456789]se considera un delimitador de argumento.

Salida

Caracteres a los stdoutdescritos anteriormente.

Ejemplo

para divide(2,3,5), todos los siguientes son resultados aceptables:

0.666
0.667
.6666
.6667
 0.666
 0.667
 .6666
 .6667
+0.666
+0.667
+.6666
+.6667

Otro ejemplo: para divide(371,3,5)lo siguiente son todos los resultados aceptables:

123.6
123.7
 123.6
 123.7
+123.6
+123.7
123.66666
123.66667
 123.66666
 123.66667
+123.66666
+123.66667

Y para divide(371,-3,5)lo siguiente son todos aceptables:

-123.6
-123.7
-123.66666
-123.66667

Java, 92/128

void d(long a,int b,int c){if(a<0^b<0){a=-a;p('-');}for(p(a/b+".");c>0;c--)p((a=a%b*10)/b);}<T>void p(T x){System.out.print(x);}

Tuve que improvisar para que ao bpudiera ser -2147483648 ya que los enteros positivos de 32 bits solo cuentan para 2147483647, por eso se aconvirtió en a long. Podría haber una mejor manera de manejar los resultados negativos, pero sé que ninguno ( doubles probablemente haría que esto funcione abs(a) < abs(b)como lo han hecho, -0pero solo el complemento de uno mantendría la precisión).

¿Por qué dos números de byte? Necesitaba 92 bytes para el cálculo y 36 para el asistente de impresión ( System.out.printapesta; generalmente Java no es tan golfoso).

public class Div {

    void d(long a, int b, int c) {
        if (a < 0 ^ b < 0) {
            a = -a;
            p('-');
        }
        for (p(a / b + "."); c > 0; c--) {
            p((a = a % b * 10) / b);
        }
    }

    <T> void p(T x) {
        System.out.print(x);
    }

    public static void main(String[] args) {
        final Div div = new Div();
        div.d(12345, 234, 20);
        div.p('\n');
        div.d(-12345, 234, 20);
        div.p('\n');
        div.d(234, 234, 20);
        div.p('\n');
        div.d(-234, 234, 20);
        div.p('\n');
        div.d(234, 12345, 20);
        div.p('\n');
        div.d(234, -12345, 20);
        div.p('\n');
        div.d(-234, 12345, 20);
        div.p('\n');
        div.d(-234, -12345, 20);
        div.p('\n');
        div.d(-2147483648, 2147483647, 20);
        div.p('\n');
        div.d(2147483647, -2147483648, 20);
        div.p('\n');
    }
}

El método básicamente ejercita lo que la mayoría de nosotros aprendimos en la escuela para generar los dígitos decimales solicitados.

C, 98 95 89

d(a,b,c){if(a>0^b>0)a=-a,printf("-");for(printf("%d.",a/b);c--;putchar(a/b+48))a=a%b*10;}

imprime cdígitos después del.

salida de ejemplo:

d(2,3,5);
0.66666

d(-2,3,5);
-0.66666

d(24352345,31412,500);
775.25611231376543995925124156373360499172290844263338851394371577740990704189481726728638736788488475741754743410161721635043932255189099707118298739335285878008404431427479943970457150133706863618999108620909206672609193938622182605373742518782630841716541449127721889723672481854068508850120972876607665860180822615560932127849229593785814338469374761237743537501591748376416656055010823888959633261174073602444925506175983700496625493441996689163377053355405577486310963962816757926906914554947153953

d(-77,12346463,500);
-0.00000623660395693892250760399962321192717298873369644407471192356871761572524859953818352673150196943043525906974329409159530142357369879940514137530724386409289850866600418273638369142644334656816288195250736992448768525852302801215214430238036593962173620088603513411087855687900251270343579371679160258286118056645048869461642577311412993340683886551152342172814999729072204727783171585254821563066280601982932277851559592411203111368818745903178910429650985873444078680671541315111866451144752954

debería funcionar para -2147483647 <= a <= 2147483647, lo mismo para b. manejar el -fue un dolor.

versión en línea: ideone

PHP, 108

function d($a,$b,$c){$a*$b<0&&$a*=-print'-';for($p='.';$c--;$a.=0,print$i.$p,$p='')$a-=$b*$i=($a-$a%$b)/$b;}

Funciona simplemente emitiendo el cociente de a/ bdurante un ciclo de cpasos, aconvirtiéndose el resto multiplicado por 10 en cada iteración.

MANIFESTACIÓN

Python 111

f=lambda a,b,c:'-'[a*b>=0:]+'%s'%reduce(lambda(d,r),c:(d%c*10,r+`d/c`+'.'[r!='':],),[abs(b)]*c,(abs(a),''))[-1]

Esta solución no viola ninguna de las reglas establecidas.

C: 72 caracteres

d(a,b,c){for(printf("%d.",a/b);c--;putchar((a=abs(a)%b*10)/abs(b)+48));}

Hace casi por completo lo que se supone que debe hacer. Sin embargo, como algunas de las otras respuestas aquí, dará valores inestables o fallará, d(-2147483648,b,c)y d(a,-2147483648,c)dado que el valor absoluto de -2147483648 está fuera de los límites para una palabra de 32 bits.

Perl, sin aritmética, 274 bytes

Esta es una división larga euclidiana , que probablemente consuma una cantidad inusual de memoria. Lo más parecido a las matemáticas en números de punto flotante es usar operaciones de bits para analizarlas.

sub di{($v,$i,$d,$e)=(0,@_);($s,$c,$j)=$i=~s/-//g;$s^=$d=~s/-//g;
$i=~s/\.(\d+)/$j=$1,""/e;$d=~s/\.(\d+)/$c=$1,""/e;
$z=0.x+length($c|$j);$i.=$j|$z;$d.=$c|$z;
($e,$m,$z,$t)=(1.x$e,0.x$i,0.x$d,"-"x($s&1));
for(;$e;$t.="."x!$v,$v=chop$e){$t.=$m=~s/$z//g||0;$m="$m"x10}
print"$t\n"}

Ejemplos:

di(-355,113,238);
di(1.13,355,239);
di(27942,19175,239);
di(1,-90.09,238);
di("--10.0","----9.801",239);
di(".01",".200",239);

Salida:

-3.141592920353982300884955752212389380530973451327433628318
584070796460176991150442477876106194690265486725663716814159
292035398230088495575221238938053097345132743362831858407079
646017699115044247787610619469026548672566371681415929203539

0.0031830985915492957746478873239436619718309859154929577464
788732394366197183098591549295774647887323943661971830985915
492957746478873239436619718309859154929577464788732394366197
183098591549295774647887323943661971830985915492957746478873

1.4572099087353324641460234680573663624511082138200782268578
878748370273794002607561929595827900912646675358539765319426
336375488917861799217731421121251629726205997392438070404172
099087353324641460234680573663624511082138200782268578878748

-0.011100011100011100011100011100011100011100011100011100011
100011100011100011100011100011100011100011100011100011100011
100011100011100011100011100011100011100011100011100011100011
100011100011100011100011100011100011100011100011100011100011

1.0203040506070809101112131415161718192021222324252627282930
313233343536373839404142434445464748495051525354555657585960
616263646566676869707172737475767778798081828384858687888990
919293949596979900010203040506070809101112131415161718192021

0.0500000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000

Rubí, 178

def d(a,b,c)
    n=(a<0)^(b<0)
    a=-a if n
    m=a/b-b/a
    l=m.to_s.size-1
    g=(a*10**(10+c)/b).to_s
    f=m<0?"."+"0"*(l-1)+g[0..c-l-1] : g[0..l]+"."+g[l+1..c-2]
    p n ? "-"+f : f
end

Versión en línea para pruebas.

El truco consiste en multiplicar un con un número bastante alto, por lo que el resultado es solo un múltiplo entero de la operación de coma flotante. Luego, el punto y los ceros deben insertarse en el lugar correcto de la cadena resultante.

Python 92 bytes:

def d(a,b,c):c-=len(str(a/b))+1;e=10**c;a*=e;a/=b;a=str(a);x=len(a)-c;return a[:x]+'.'+a[x:]

Creo que un poco más de golf es posible .....

C 83

d(a,b,c){printf("%d.",a/b);for(a=abs(a),b=abs(b);c--&&(a=a%b*10);)putchar(a/b+48);}

La misma idea que usé en mi implementación de Python