Ecrire un programme ou une fonction qui prend en nombres entiers positifs a, bet c, et des impressions ou des retours a/bà cdécimales, en utilisant les opérations + - * /% [ajouter, soustraire, multiplier, diviser, modulent] sur les nombres entiers positifs: vous pouvez utiliser tout ce qui votre langue le permet, mais pas sur les nombres à virgule flottante. La plage de a, b, c serait la plage autorisée pour les entiers non signés dans votre langue. Le résultat numérique sera tronqué au dernier chiffre à imprimer (donc non round).

Cela signifie que si votre langue n'a pas de type entier (flottant uniquement), vous pouvez participer en utilisant ces nombres flottants uniquement comme des entiers positifs. L'indice de cet exercice serait d'écrire la fonction qui trouve les chiffres dans une division en virgule flottante, en utilisant uniquement l'opération + - * /% sur des entiers [non signés].

Exemples

• print(1,2,1) imprimerait 0.5
• print(1,2,2) imprimerait 0.50
• print(13,7,27) imprimerait 1.857142857142857142857142857
• print(2,3,1) imprimerait 0.6
• print(4,5,7) imprimerait 0.8000000
• print(4,5,1) imprimerait 0.8
• print(9999,23,1) imprimerait 434.7
• print(12345613,2321,89) imprimerait si votre langue a 32 bits non signés 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Le code le plus court en octets gagne. Je suis désolé si cela n'apparaît pas clairement ... Je ne connais pas non plus les langues, je ne me souviens pas bien des mots ... Il vaut mieux avoir un lien vers Ideone.com ou un autre endroit pour essayer facilement la réponse spécialement pour tester une entrée différente de celle proposée.

05AB1E , 17 13 11 19 14 octets

Saisie dans le formulaire b, a, c.
Enregistré 5 octets grâce à Grimy .

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

Essayez-le en ligne!

Haskell, 87 octets

(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

Exemple d'utilisation: (13#7)27-> "1.857142857142857142857142857".

23 octets pour gérer le c==0cas et utiliser un zéro non significatif au lieu de choses comme .5.

Comment ça marche: multiplier aavec 10^c, diviser par b, transformer en une chaîne, diviser où le .doit être inséré, joindre les deux parties avec un .entre-deux et fixer les cas de bord.

Perl 6 ,  58 57 55  48 octets

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

Ce qui est assez ennuyeux, c'est qu'il pourrait être réduit à juste {($^a.FatRat/$^b).base(10,$^c)}s'il était autorisé à arrondir à la valeur la plus proche.

Explication:

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

Comprend +3 pour -p

Donnez a et b sur une ligne sur STDIN, c sur la suivante

division.pl
1 26
38
^D

division.pl:

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

l' $_/$&est un peu défendables de. Je veux en fait une division entière mais perl n'en a pas sans charger des modules spéciaux. C'est donc temporairement un non-entier que je tronque immédiatement (en utilisant |0) donc je me retrouve avec l'entier qu'une division entière donnerait. Il pourrait être réécrit ($_-$_%$&)/$&afin de ne pas avoir même temporairement une valeur non entière (ce serait cependant en interne un flottant)

JavaScript (ES6), 55 50 octets

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

(a/b|0)effectue la division flottante mais transforme immédiatement en un entier. Veuillez me faire savoir si cela n'est pas autorisé.

PHP, 187 octets

fonctionne avec des chaînes pour le numérateur qui peuvent être des valeurs int supérieures à 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);

Je n'ai aucune autre chance alors 13/7 est raccourci à 1.8571428571429 et j'atteins donc pas le cas de test avec 27 décimales

De cette façon, 36 octets ne sont pas autorisés

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

Pyth - 21 19 18 16 14 octets

Sera à la recherche sur le format d'entrée, qui peut prolly enregistrer un tas.

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

Suite de tests . (PS le 27 ne termine pas en ligne, donc j'en ai fait 10 à la place).

JavaScript (ES6),  64  62 59 octets

Sauvegardé 2 octets grâce à ETHproductions.

La division incluse donne toujours un entier.

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 octets

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

Code non testé et testé:

Essayez-le ici.

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

Production:

0.5
0.50
1.857142857142857142857142857
0.6
0.8000000
0
434
5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Rubis, 67 octets

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

si j'en fais une fonction pour exécuter les cas de test ci-dessus

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 

Raquette 203 octets

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

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

Usage:

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

Production:

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

Autre méthode (réponse non valable ici):

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

q, 196 octets

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

Pour exécuter: définissez d'abord a, b, c.

Rouille, 114 octets

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

code de test:

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 octets

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

intdiv () est introduit en php 7 donc il nécessite cela. php 7.1 me permettrait de changer la liste () en [] et économiserait ainsi 4 octets.

utiliser comme:

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 octets

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

Programme complet avec cas de 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 division entière est implémentée. Des nombres de n'importe quelle taille peuvent être utilisés, en raison du BigIntegertype de données (l'importation System.Numericsest requise). Le paramètre de nombre de chiffres cest limité à 2 ^ 31-1, mais il doit fournir plus qu'assez de chiffres.

Groovy ( 78 77 42 octets)

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

Explication

Eval.me(a+'.0g');- Conversion de l'entrée entière en entrée BigDecimal. En groovy, la notation BigDecimal est une notation double avec un G ou g ajouté. J'aurais aussi pu utiliser le constructeur new BigDecimal(it)mais cela a sauvé un octet.
.divide(b, n, 1)- Divisez par b avec n précision, mode d'arrondi à moitié.

Essayez-le ici: https://groovyconsole.appspot.com/script/5177545091710976

Lot, 122 octets

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

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

Fonction Sans nom de trois arguments (qui sont commandés c, a, bpour sauver un quelque part octet), qui renvoie une chaîne. Il multiplie a/bpar 10^c, prend la plus grande fonction entière, puis se convertit en chaîne et insère une virgule décimale à l'endroit approprié. Dommage que les noms de fonction ne soient pas plus courts.

Python 3, 62 octets

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

Essayez-le ici

* Remarque : repl.it utilise une version plus ancienne de Python 3 , qui nécessite que tous les indices de champ soient spécifiés, ce "{:.{1}f}"qui signifie que ce sera le cas "{0:.{1}f}", ce qui en fait 63 octets dans repl.it

Comment utiliser

Entrez les trois valeurs avec des espaces entre les deux. c'est-à-dire qu'une entrée de 1 2 1donnerait un résultat de0.5

Explication

input().split(): Obtient une entrée utilisateur et la divise en une liste avec un séparateur de (espace)

a,b,c = map(int,XX): Mappe les variables dans les valeurs spécifiées par l'utilisateur avec un type int

"{:.{1}f}".format(a/b,c): Formate une chaîne pour afficher le résultat de la division et remplace {1}parc pour définir la décimale de la chaîne affichée

print(XX): imprime la chaîne fournie

Python 3 , 58 octets

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

Essayez-le en ligne!

Ceci est précis pour le nombre de décimales spécifié tant que a * 10 ** c n'est pas trop grand.

J'ai essayé Python 2 pour raccourcir le str(...)to `...`mais Python 2 insère un Là la fin s'il est trop grand, donc la vérification prendrait bien plus d'octets que cela ne vaut.

Stax , 13 octets

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

Exécuter et déboguer

Les arguments sont acceptés dans l' c a bordre.

C, 67 octets

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

Essayez-le en ligne!

Une version précédente, je pense, avait un bug dans la mémoire de lecture qui n'était pas affecté au programme ... Merci à plafondcat et pour tous ...