Napisać program lub funkcję, która przyjmuje w dodatnich liczb całkowitych a, bi c, i drukuje lub powraca a/bdo cmiejsc po przecinku, przy zastosowaniu operacji + - * /% [dodawanie, odejmowanie, mnożenie, dzielenie, modulate] na dodatnich liczb całkowitych: można użyć wszystkiego, twój język pozwala, ale nie na liczbach zmiennoprzecinkowych. Zakres a, b, c będzie zakresem dozwolonym dla liczb całkowitych bez znaku w twoim języku. Wynik liczbowy zostanie obcięty do ostatniej cyfry do wydrukowania (więc nie round).

Oznacza to, że jeśli twój język nie ma typu liczb całkowitych (tylko liczba zmiennoprzecinkowa), możesz uczestniczyć, używając tych liczb zmiennoprzecinkowych tylko jako dodatnich liczb całkowitych. Istotą tego ćwiczenia byłoby napisanie funkcji, która znajdzie cyfry w podziale zmiennoprzecinkowym, używając tylko operacji + - * /% na liczbach całkowitych [niepodpisanych].

Przykłady

• print(1,2,1) wydrukuje 0.5
• print(1,2,2) wydrukuje 0.50
• print(13,7,27) wydrukuje 1.857142857142857142857142857
• print(2,3,1) wydrukuje 0.6
• print(4,5,7) wydrukuje 0.8000000
• print(4,5,1) wydrukuje 0.8
• print(9999,23,1) wydrukuje 434.7
• print(12345613,2321,89) wypisuje się, jeśli Twój język ma 32-bitowy niepodpisany 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Najkrótszy kod w bajtach wygrywa. Przykro mi, jeśli wydaje się to niejasne ... Nie znam również języków, nie pamiętam dobrze słów ... Lepiej mieć jeden link do Ideone.com lub innego miejsca, aby łatwo wypróbować odpowiedź, szczególnie dla przetestuj niektóre dane wejściowe inne niż proponowane.

05AB1E , 17 13 11 19 14 bajtów

Wprowadź w formularzu b, a, c.
Zaoszczędzono 5 bajtów dzięki Grimy .

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

Wypróbuj online!

Haskell, 87 bajtów

(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

Przykład użycia: (13#7)27-> "1.857142857142857142857142857".

23 bajty do obsługi c==0sprawy i użycie wiodącego zera zamiast rzeczy takich jak .5.

Jak to działa: pomnóż aprzez 10^c, podziel przez b, zamień w ciąg, podziel w miejscu, w którym .należy wstawić, połącz obie części .pomiędzy nimi i napraw skrzynie krawędzi.

Perl 6 ,  58 57 55  48 bajtów

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

Dość denerwujące jest to, że można by go skrócić do tego samego poziomu, {($^a.FatRat/$^b).base(10,$^c)}gdyby pozwolono mu zaokrąglić do najbliższej wartości.

Wyjaśnienie:

# 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 bajtów

Obejmuje +3 za -p

Podaj aib w jednej linii na STDIN, c w następnej

division.pl
1 26
38
^D

division.pl:

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

$_/$&jest nieco dyskusyjna. Właściwie chcę tam podział na liczby całkowite, ale Perl nie ma go bez ładowania specjalnych modułów. Jest to więc tymczasowo niecałkowita, którą następnie natychmiast obcinam (za pomocą |0), więc kończę na liczbie całkowitej, jaką dałby podział liczb całkowitych. Można go przepisać ($_-$_%$&)/$&, aby nawet chwilowo nie miał wartości niecałkowitej (choć wewnętrznie nadal byłby zmiennoprzecinkowy)

JavaScript (ES6), 55 50 bajtów

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

(a/b|0)wykonuje dzielenie zmiennoprzecinkowe, ale natychmiast rzuca na liczbę całkowitą. Daj mi znać, jeśli nie jest to dozwolone.

PHP, 187 bajtów

działa z łańcuchami licznika, które mogą być wartościami int większymi niż 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);

Nie mam innej szansy, więc 13/7 skraca się do 1,8571428571429 i docieram więc nie do przypadku testowego z 27 miejscami dziesiętnymi

W ten sposób 36 bajtów nie jest dozwolone

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

Pyth - 21 19 18 16 14 bajtów

Sprawdzę format wejściowy, który może uratować wiele.

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

Pakiet testowy . (PS 27 nie kończy się online, więc zrobiłem 10 zamiast tego).

JavaScript (ES6),  64  62 59 bajtów

Zaoszczędzono 2 bajty dzięki produktom ETH.

Uwzględniony podział zawsze skutkuje liczbą całkowitą.

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 bajtów

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

Kod niepoznany i testowy:

Wypróbuj tutaj.

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

Wynik:

0.5
0.50
1.857142857142857142857142857
0.6
0.8000000
0
434
5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Rubin, 67 bajtów

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

jeśli uczynię to funkcją wykonywania powyższych przypadków testowych

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 

Rakieta 203 bajtów

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

Nie golfowany:

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

Stosowanie:

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

Wynik:

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

Inna metoda (niepoprawna odpowiedź tutaj):

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

q 196 bajtów

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

Aby uruchomić: najpierw ustaw a, b, c.

Rdza, 114 bajtów

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

kod testowy:

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 bajtów

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

intdiv () jest wprowadzony w php 7, więc wymaga tego. php 7.1 pozwoli mi zmienić list () na [], a tym samym zaoszczędzi 4 bajty.

użyj jak:

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 bajtów

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

Pełny program z przypadkami testowymi:

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

Wprowadzono podział na liczby całkowite. Można użyć liczb o dowolnym rozmiarze, ze względu na BigIntegertyp danych ( System.Numericswymagany jest import ). Parametr liczby cyfr cjest ograniczony do 2 ^ 31-1, jednak powinien zawierać więcej niż wystarczającą liczbę cyfr.

Groovy ( 78 77 42 bajtów)

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

Wyjaśnienie

Eval.me(a+'.0g');- Konwertuj z wejścia liczb całkowitych na dane wejściowe BigDecimal. W groovy notacji BigDecimal jest notacja podwójna z dołączonym G lub g. Mógłbym również użyć konstruktora, new BigDecimal(it)ale to uratowało bajt.
.divide(b, n, 1)- Podziel przez bz precyzją n, tryb zaokrąglania do połowy.

Wypróbuj tutaj: https://groovyconsole.appspot.com/script/5177545091710976

Partia, 122 bajty

@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 bajtów

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

Nienazwany funkcją trzech argumentów (które zostały zamówione c, a, baby zapisać gdzieś bajt), która zwraca ciąg znaków. Mnoży się a/bprzez 10^c, przyjmuje największą funkcję całkowitą, a następnie konwertuje na ciąg i wstawia kropkę dziesiętną w odpowiednim miejscu. Szkoda, że ​​nazwy funkcji nie są krótsze.

Python 3, 62 bajtów

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

Wypróbuj tutaj

* Uwaga : repl.it używa starszej wersji Python 3 , która wymaga określenia wszystkich indeksów pól, co oznacza "{:.{1}f}", że "{0:.{1}f}"zamiast tego, będzie to 63 bajty w repl.it

Jak używać

Wprowadź wszystkie trzy wartości ze spacjami pomiędzy nimi. tzn. Dane wejściowe 1 2 1dają wynik0.5

Wyjaśnienie

input().split(): Pobiera dane wejściowe użytkownika i dzieli je na listę z separatorem (spacja)

a,b,c = map(int,XX): Odwzorowuje zmienne na wartości określone przez użytkownika za pomocą typu int

"{:.{1}f}".format(a/b,c): Formatuje ciąg, aby wyświetlić wynik podziału i zastępuje {1}go, caby ustawić miejsce dziesiętne wyświetlanego ciągu

print(XX): drukuje dostarczony ciąg

Python 3 , 58 bajtów

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

Wypróbuj online!

Jest to dokładne z określoną liczbą miejsc po przecinku, o ile a * 10 ** cnie jest zbyt duże.

Próbowałem Python 2, aby skrócić str(...)do `...`ale Pythonie 2 wstawia Lna końcu jeśli jest zbyt duży, więc sprawdzenie zajęłoby sposób więcej bajtów niż to warte.

Stax , 13 bajtów

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

Uruchom i debuguj

Argumenty są akceptowane w c a bkolejności.

C, 67 bajtów

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

Wypróbuj online!

Pewna poprzednia wersja, jak sądzę, miała błąd w pamięci odczytu poza przypisanym do programu ... Dzięki pułapce cat i wszystkim ...