Escreva um programa ou função que leva em inteiros positivos a, be c, e impressões ou retorna a/bpara ccasas decimais, utilizando as operações + - * /% [somar, subtrair, multiplicar, dividir, modular] sobre os inteiros positivos: você pode usar tudo o que seu idioma permite, mas não em números de ponto flutuante. O intervalo de a, b, c seria o intervalo permitido para números inteiros não assinados no seu idioma. O resultado do número será truncado para o último dígito a ser impresso (portanto, não round).

Isso significa que, se o seu idioma não tiver um tipo inteiro (apenas flutuante), você poderá participar usando esses números flutuantes apenas como números inteiros positivos. A pista deste exercício seria escrever a função que encontra os dígitos em uma divisão de ponto flutuante, usando apenas a operação + - * /% em números inteiros [não assinados].

Exemplos

• print(1,2,1) imprimiria 0.5
• print(1,2,2) imprimiria 0.50
• print(13,7,27) imprimiria 1.857142857142857142857142857
• print(2,3,1) imprimiria 0.6
• print(4,5,7) imprimiria 0.8000000
• print(4,5,1) imprimiria 0.8
• print(9999,23,1) imprimiria 434.7
• print(12345613,2321,89) seria impresso se o seu idioma não tiver assinatura de 32 bits 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

O código mais curto em bytes vence. Sinto muito se isso não parece claro ... Também não conheço idiomas, não lembro bem as palavras ... É melhor ter um link para Ideone.com ou algum outro lugar para tentar facilmente a resposta, especialmente para teste alguma entrada diferente da proposta.

05AB1E , 17 13 11 19 14 bytes

Entrada no formulário b, a, c.
Economizou 5 bytes graças ao Grimy .

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

Experimente online!

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

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

23 bytes para lidar com o c==0caso e usar um zero à esquerda em vez de coisas do tipo .5.

Como funciona: multiplique acom 10^c, divida por b, transforme-se em uma sequência, divida onde .deve ser inserido, junte as duas partes com um .intermediário e corrija as arestas.

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}

O que é bastante irritante é que poderia ser reduzido para apenas {($^a.FatRat/$^b).base(10,$^c)}se fosse permitido arredondar para o valor mais próximo.

Explicação:

# 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

Inclui +3 para -p

Dê aeb em uma linha em STDIN, c na próxima

division.pl
1 26
38
^D

division.pl:

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

o $_/$&é um pouco discutível. Na verdade, eu quero uma divisão inteira lá, mas o perl não tem isso sem carregar módulos especiais. Portanto, é temporariamente um não inteiro que eu imediatamente trunco ​​(usando |0) para terminar com o inteiro que uma divisão inteira daria. Ele pode ser reescrito ($_-$_%$&)/$&para não ter um valor não inteiro temporariamente (ainda assim seria internamente um valor flutuante)

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)executa a divisão de flutuação, mas lança imediatamente para um número inteiro. Informe-me se isso não for permitido.

PHP, 187 bytes

trabalha com strings para o numerador, que podem ser valores int maiores 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);

Não tenho outra chance, então 13/7 é reduzido para 1,8571428571429 e chego a isso, não o caso de teste com 27 casas decimais

Dessa forma, 36 bytes não são permitidos

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

Pitão - 21 19 18 16 14 bytes

Estará olhando sobre o formato de entrada, que pode economizar bastante.

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

Conjunto de Teste . (PS 27 não termina online, então eu fiz 10 em seu lugar).

JavaScript (ES6),  64  62 59 bytes

Saved 2 bytes thanks to ETHproductions.

The included division always results in an integer.

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 & código de teste:

Experimente aqui.

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

Resultado:

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

se eu fizer uma função para executar os casos de teste acima

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 

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

Ungolfed:

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

Resultado:

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

Outro método (resposta não válida aqui):

(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 executar: defina a, b, c primeiro.

Ferrugem, 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 teste:

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 () é introduzido no php 7, portanto é necessário. O php 7.1 me permitiria mudar a lista () para [] e, assim, economizaria 4 bytes.

use 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 com casos de teste:

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

Divisão inteira é implementada. Podem ser usados ​​números de qualquer tamanho, devido ao BigIntegertipo de dados (a importação System.Numericsé necessária). O parâmetro de contagem de dígitos cé restrito a 2 ^ 31-1, no entanto, deve fornecer dígitos mais que suficientes.

Groovy ( 78 77 42 bytes)

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

Explicação

Eval.me(a+'.0g');- Converta da entrada inteira para a entrada BigDecimal. Na notação BigDecimal groovy, há uma notação dupla com um G ou g anexado. Eu também poderia ter usado o construtor, new BigDecimal(it)mas isso salvou um byte.
.divide(b, n, 1)- Divida por b com precisão n, modo de arredondamento pela metade.

Experimente aqui: 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]&

Função Sem nome dos três argumentos (que são encomendadas c, a, bpara salvar a algum lugar byte), que retorna um string. Ele multiplica a/bpor 10^c, leva a maior função inteiro, em seguida, convertidos para uma string e insere um ponto decimal para o local apropriado. Pena que os nomes das funções não sejam mais curtos.

Python 3, 62 bytes

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

Experimente aqui

* Nota : repl.it usa uma versão mais antiga do Python 3 , que requer que todos os índices de campo sejam especificados, o que significa que o "{:.{1}f}"fará "{0:.{1}f}", com 63 bytes em repl.it

Como usar

Digite todos os três valores com espaços intermediários. isto é, uma entrada de1 2 1 daria um resultado de0.5

Explicação

input().split(): Obtém a entrada do usuário e a divide em uma lista com um separador de (espaço)

a,b,c = map(int,XX): Mapeia as variáveis ​​para os valores especificados pelo usuário com um tipo int

"{:.{1}f}".format(a/b,c): Formata uma sequência para exibir o resultado da divisão e substitui {1}porc para definir a casa decimal da sequência exibida

print(XX): imprime a sequência fornecida

Python 3 , 58 bytes

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

Experimente online!

Isso é preciso para o número especificado de casas decimais, desde que a * 10 ** c não seja muito grande.

Eu tentei o Python 2 para encurtar o str(...)para, `...`mas o Python 2 insere um Lno final, se for muito grande, portanto, verificar isso levaria muito mais bytes do que vale a pena.

Stax , 13 bytes

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

Execute e depure

Os argumentos são aceitos em c a bordem.

C, 67 bytes

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

Experimente online!

Alguma versão anterior eu acho que tinha um erro na memória de leitura fora do atribuído ao programa ... Graças a ceilingcat e para todos ...