Schreiben Sie ein Programm oder eine Funktion , die in positive ganze Zahlen nimmt a, bund c, und druckt oder kehrt a/bzu cDezimalstellen, mit den Operationen + - * /% [addieren, subtrahieren, multiplizieren, dividieren, modulieren] auf die positiven ganzen Zahlen: Sie können alle verwenden , die Ihre Sprache erlaubt, aber nicht auf Gleitkommazahlen. Der Bereich von a, b, c ist der Bereich, der für vorzeichenlose ganze Zahlen in Ihrer Sprache zulässig ist. Das Zahlenergebnis wird auf die letzte zu druckende Ziffer gekürzt (also nein round).

Dies bedeutet, dass Sie teilnehmen können, wenn Ihre Sprache keinen Integer-Typ (nur Float) hat, indem Sie diese Float-Zahlen nur als positive Ganzzahlen verwenden. Der Schlüssel dieser Übung wäre, die Funktion zu schreiben, die die Ziffern in einer Gleitkommadivision findet, wobei nur die Operation + - * /% für [vorzeichenlose] Ganzzahlen verwendet wird.

Beispiele

• print(1,2,1) würde drucken 0.5
• print(1,2,2) würde drucken 0.50
• print(13,7,27) würde drucken 1.857142857142857142857142857
• print(2,3,1) würde drucken 0.6
• print(4,5,7) würde drucken 0.8000000
• print(4,5,1) würde drucken 0.8
• print(9999,23,1) würde drucken 434.7
• print(12345613,2321,89) würde drucken, wenn Ihre Sprache 32 Bit ohne Vorzeichen hat 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Der kürzeste Code in Bytes gewinnt. Es tut mir leid, wenn dies nicht klar zu sein scheint ... Ich kann mich auch nicht an Sprachen und Wörter erinnern Testen Sie einige Eingaben, die sich von den vorgeschlagenen unterscheiden.

05AB1E , 17 13 11 19 14 Bytes

Eingabe in das Formular b, a, c.
5 Bytes dank Grimy gespart .

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

Probieren Sie es 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

Anwendungsbeispiel: (13#7)27-> "1.857142857142857142857142857".

23 Bytes, um den c==0Fall zu behandeln und eine führende Null anstelle von Dingen wie zu verwenden .5.

Wie es funktioniert: multiplizieren amit 10^c, dividieren durch b, in eine Zeichenfolge verwandeln , teilen , wo das .eingefügt werden muss, beide Teile mit einem .dazwischen verbinden und die Kantenhüllen befestigen.

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}

Was ziemlich ärgerlich ist, ist, dass es auf genau das gekürzt werden könnte, was {($^a.FatRat/$^b).base(10,$^c)}auf den nächsten Wert gerundet werden darf.

Erläuterung:

# 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

Beinhaltet +3 für -p

Geben Sie a und b in einer Zeile bei STDIN und c in der nächsten Zeile ein

division.pl
1 26
38
^D

division.pl:

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

das $_/$&ist ein bisschen umstritten. Eigentlich möchte ich dort eine Ganzzahldivision, aber Perl hat das nicht, ohne spezielle Module zu laden. Es ist also vorübergehend eine Nicht-Ganzzahl, die ich dann sofort abschneide (benutze |0), damit ich die Ganzzahl erhalte, die eine Ganzzahldivision ergibt. Es könnte so umgeschrieben ($_-$_%$&)/$&werden, dass es nicht einmal vorübergehend einen nicht ganzzahligen Wert hat (intern wäre es jedoch immer noch ein 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)Führt eine Float-Division durch, wandelt sich aber sofort zu einer Ganzzahl. Bitte lassen Sie mich wissen, wenn dies nicht erlaubt ist.

PHP, 187 Bytes

arbeitet mit Strings für den Zähler, die int-Werte größer als sein können 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);

Ich habe keine andere Chance als 13/7 auf 1.8571428571429 zu verkürzen und ich erreiche damit nicht den Testfall mit 27 Nachkommastellen

Auf diese Weise sind 36 Bytes nicht zulässig

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

Pyth - 21 19 18 16 14 Bytes

Werde mal über das Eingabeformat schauen, das einen Haufen sparen kann.

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

Test Suite . (PS, die 27 endet nicht online, also habe ich stattdessen 10 gemacht).

JavaScript (ES6),  64  62 59 Bytes

2 Bytes gespart dank ETHproductions.

Die eingeschlossene Division ergibt immer eine ganze Zahl.

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 & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

wenn ich es zu einer Funktion mache, die obigen Testfälle auszuführen

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 

Schläger 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 )))

Verwendung:

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

Ausgabe:

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

Andere Methode (ungültige Antwort hier):

(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

Zum Ausführen: Stellen Sie zuerst a, b, c ein.

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

Testcode:

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 () ist in PHP 7 eingeführt, so dass es das erfordert. PHP 7.1 würde mir erlauben, die Liste () zu [] zu ändern und so 4 Bytes zu sparen.

verwenden wie:

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

Volles Programm mit Testfällen:

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

Integer Division ist implementiert. Zahlen jeder Größe können aufgrund des BigIntegerDatentyps verwendet werden (der Import System.Numericsist erforderlich). Der Digit-Count-Parameter cist auf 2 ^ 31-1 beschränkt, sollte jedoch mehr als genug Ziffern enthalten.

Groovy ( 78 77 42 Bytes)

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

Erläuterung

Eval.me(a+'.0g');- Konvertieren von Integer-Eingabe in BigDecimal-Eingabe. In der groovigen BigDecimal-Notation ist dies die doppelte Notation mit einem angehängten G oder g. Ich hätte auch den Konstruktor verwenden können, new BigDecimal(it)aber dadurch wurde ein Byte gespeichert.
.divide(b, n, 1)- Mit n Genauigkeit durch b teilen, Rundungsmodus halbieren.

Versuchen Sie es hier: https://groovyconsole.appspot.com/script/5177545091710976

Batch, 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]&

Unbenannte Funktion von drei Argumenten (die geordnet csind a, bum ein Byte irgendwo zu speichern), die eine Zeichenfolge zurückgeben. Es multipliziert a/bmit 10^c, übernimmt die größte Ganzzahlfunktion, konvertiert dann in eine Zeichenfolge und fügt an der entsprechenden Stelle einen Dezimalpunkt ein. Schade, dass die Funktionsnamen nicht kürzer sind.

Python 3, 62 Bytes

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

Probieren Sie es hier

* Hinweis : repl.it eine ältere verwendet ver von Python 3 , die alle Feldindizes erfordert angegeben werden, was bedeutet , "{:.{1}f}"wird "{0:.{1}f}"statt, so dass es 63 Bytes in repl.it

Wie benutzt man

Geben Sie alle drei Werte mit Leerzeichen dazwischen ein. Dh eine Eingabe von 1 2 1würde ein Ergebnis von ergeben0.5

Erläuterung

input().split(): Ruft Benutzereingaben ab und teilt sie in eine Liste mit dem Trennzeichen (Leerzeichen)

a,b,c = map(int,XX): Ordnet die Variablen den vom Benutzer angegebenen Werten mit einem Int-Typ zu

"{:.{1}f}".format(a/b,c): Formatiert einen String mit dem Divisionsergebnis und Ersatz angezeigt {1}mitc , um die Dezimalstelle der angezeigten Zeichenfolge festzulegen

print(XX): druckt die gelieferte Zeichenfolge

Python 3 , 58 Bytes

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

Probieren Sie es online!

Dies ist auf die angegebene Anzahl von Dezimalstellen genau, solange a * 10 ** ces nicht zu groß ist.

Ich habe versucht, Python 2 zu verkürzen str(...), `...`aber Python 2 fügt Lam Ende eine ein, wenn es zu groß ist, so dass es viel mehr Bytes kostet, danach zu suchen, als es wert ist.

Stax , 13 Bytes

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

Führen Sie es aus und debuggen Sie es

Argumente werden in der c a bReihenfolge akzeptiert .

C 67 Bytes

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

Probieren Sie es online!

Einige Vorgängerversionen hatten, glaube ich, einen Fehler im Lesespeicher, der dem Programm zuzuordnen war ... Dank ceilingcat und für alle ...