Scrivere un programma o una funzione che prende in numeri interi positivi a, be c, e le stampe o ritorni a/ba ccifre decimali, utilizzando le operazioni + - * /% [addizione, sottrazione, moltiplicazione, divisione, modulate] sugli interi positivi: è possibile utilizzare tutto ciò che la tua lingua lo consente, ma non sui numeri in virgola mobile. L'intervallo di a, b, c sarebbe l'intervallo consentito per numeri interi senza segno nella tua lingua. Il risultato numerico verrà troncato all'ultima cifra da stampare (quindi no round).

Ciò significa che se la tua lingua non ha un tipo intero (solo float), puoi partecipare usando questi numeri float solo come numeri interi positivi. L'indizio di questo esercizio sarebbe scrivere la funzione che trova le cifre in una divisione in virgola mobile, usando solo l'operazione + - * /% su numeri interi [senza segno].

Esempi

• print(1,2,1) stamperebbe 0.5
• print(1,2,2) stamperebbe 0.50
• print(13,7,27) stamperebbe 1.857142857142857142857142857
• print(2,3,1) stamperebbe 0.6
• print(4,5,7) stamperebbe 0.8000000
• print(4,5,1) stamperebbe 0.8
• print(9999,23,1) stamperebbe 434.7
• print(12345613,2321,89) stampa se la tua lingua ha 32 bit senza segno 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Vince il codice più breve in byte. Mi dispiace se questo non sembra chiaro ... Non conosco anche le lingue, non ricordo bene le parole ... È meglio avere un link a Ideone.com o in qualche altro posto per provare facilmente la risposta soprattutto per testare alcuni input diversi da quelli proposti.

05AB1E , 17 13 11 19 14 byte

Inserisci nel modulo b, a, c.
5 byte salvati grazie a Grimy .

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

Provalo online!

Haskell, 87 byte

(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

Esempio di utilizzo: (13#7)27-> "1.857142857142857142857142857".

23 byte per gestire il c==0caso e usare uno zero iniziale invece di cose come .5.

Come funziona: si moltiplicano acon 10^c, dividere per b, si trasformano in una stringa, spaccatura in cui il .devono essere inseriti, unire entrambe le parti con un .in-between e fissare i casi limite.

Perl 6 ,  58 57 55  48 byte

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

Ciò che è abbastanza fastidioso è che potrebbe essere abbreviato solo {($^a.FatRat/$^b).base(10,$^c)}se fosse autorizzato ad arrotondare al valore più vicino.

Spiegazione:

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

Include +3 per -p

Dare aeb su una riga su STDIN, c sulla successiva

division.pl
1 26
38
^D

division.pl:

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

l' $_/$&è un po 'discutibile. In realtà voglio una divisione intera lì, ma perl non ce l'ha senza caricare moduli speciali. Quindi è temporaneamente un numero intero che poi tronco immediatamente (usando |0), quindi finisco con il numero intero che darebbe una divisione intera. Potrebbe essere riscritto come ($_-$_%$&)/$&per non avere nemmeno temporaneamente un valore non intero (sarebbe comunque internamente un float)

JavaScript (ES6), 55 50 byte

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

(a/b|0)esegue la divisione float ma esegue immediatamente il cast su un numero intero. Per favore fatemi sapere se questo non è permesso.

PHP, 187 byte

funziona con stringhe per il numeratore che possono essere valori int maggiori di allora 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);

Non ho altra possibilità, quindi il 13/7 è abbreviato a 1.8571428571429 e raggiungo quindi non il caso di test con 27 decimali

In questo modo non è consentito 36 byte

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

Pyth - 21 19 18 16 14 byte

Esamineremo il formato di input, che può salvare un sacco.

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

Test Suite . (PS il 27 non finisce online, quindi ne ho fatti 10).

JavaScript (ES6),  64  62 59 byte

Risparmiato 2 byte grazie a ETHproductions.

La divisione inclusa risulta sempre in un numero intero.

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 byte

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

Codice non testato e test:

Provalo qui.

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

Produzione:

0.5
0.50
1.857142857142857142857142857
0.6
0.8000000
0
434
5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Rubino, 67 byte

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

se lo faccio una funzione per eseguire i casi di test sopra

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 

Racchetta 203 byte

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

Produzione:

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

Altro metodo (non valida risposta qui):

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

q, 196 byte

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

Per eseguire: impostare prima a, b, c.

Ruggine, 114 byte

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

codice di prova:

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 byte

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

intdiv () è stato introdotto in php 7, quindi è necessario. php 7.1 mi permetterebbe di cambiare la lista () in [] e quindi di salvare 4 byte.

usare come:

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 byte

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

Programma completo con casi di test:

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

La divisione integer è implementata. È possibile utilizzare numeri di qualsiasi dimensione, a causa del BigIntegertipo di dati ( System.Numericsè necessaria l'importazione ). Il parametro conteggio delle cifre cè limitato a 2 ^ 31-1, tuttavia dovrebbe fornire cifre più che sufficienti.

Groovy ( 78 77 42 byte)

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

Spiegazione

Eval.me(a+'.0g');- Converti da input intero a input BigDecimal. In Groovy la notazione BigDecimal è la doppia notazione con un G o g aggiunto. Avrei potuto anche usare il costruttore new BigDecimal(it)ma questo ha salvato un byte.
.divide(b, n, 1)- Dividi per b con n precisione, arrotondando per metà.

Provalo qui: https://groovyconsole.appspot.com/script/5177545091710976

Lotto, 122 byte

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

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

Senza nome funzione di tre argomenti (che vengono ordinati c, a, bper salvare un qualche byte), che restituisce una stringa. Si moltiplica a/bper 10^c, prende la funzione intera più grande, quindi si converte in una stringa e inserisce un punto decimale nel punto appropriato. Peccato che i nomi delle funzioni non siano più brevi.

Python 3, 62 byte

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

Provalo qui

* Nota : repl.it utilizza una versione precedente di Python 3 , che richiede di specificare tutti gli indici dei campi, il che significa "{:.{1}f}"che sarà "{0:.{1}f}"invece, rendendolo 63 byte in repl.it

Come usare

Immettere tutti e tre i valori con spazi intermedi. cioè un input di 1 2 1darebbe un risultato di0.5

Spiegazione

input().split(): Ottiene l'input dell'utente e lo divide in un elenco con un separatore di (spazio)

a,b,c = map(int,XX): Mappa le variabili nei valori specificati dall'utente con un tipo int

"{:.{1}f}".format(a/b,c): Formatta una stringa per visualizzare il risultato della divisione e sostituisce {1}con cper impostare la posizione decimale della stringa visualizzata

print(XX): stampa la stringa fornita

Python 3 , 58 byte

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

Provalo online!

Questo è preciso al numero specificato di decimali purché a * 10 ** cnon sia troppo grande.

Ho provato Python 2 per accorciare la str(...)a `...`ma Python 2 inserti un Lalla fine se è troppo grande in modo controllando che richiederebbe modo più byte che vale la pena.

Stax , 13 byte

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

Esegui ed esegui il debug

Gli argomenti sono accettati in c a bordine.

C, 67 byte

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

Provalo online!

Qualche versione precedente penso che avesse un bug nella memoria di lettura non assegnato al programma ... Grazie a ceilingcat e per tutti ...