Напишіть програму або функцію, яка приймає натуральні цілі числа a, bта cдрукує або повертається a/bдо cдесяткових знаків, використовуючи операції + - * /% [додавання, віднімання, множення, ділення, модулювання] на додатні цілі числа: ви можете використовувати все це ваша мова дозволяє, але не на числах з плаваючою комою. Діапазон a, b, c буде діапазоном, дозволеним для непідписаних цілих чисел на вашій мові. Результат цифри буде прирізаний до останньої цифри для друку (тому ні round).

Це означає, що якщо ваша мова не має цілого типу (лише плаваючий), ви можете брати участь, використовуючи ці числа з плаваючою ланкою лише як додатні цілі числа. Підказкою цієї вправи було б написати функцію, яка знаходить цифри у поділі з плаваючою точкою, використовуючи лише операцію + - * /% на [непідписані] цілі числа.

Приклади

• print(1,2,1) надрукував би 0.5
• print(1,2,2) надрукував би 0.50
• print(13,7,27) надрукував би 1.857142857142857142857142857
• print(2,3,1) надрукував би 0.6
• print(4,5,7) надрукував би 0.8000000
• print(4,5,1) надрукував би 0.8
• print(9999,23,1) надрукував би 434.7
• print(12345613,2321,89) буде надруковано, якщо у вашій мові є 32 біти без підпису 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Виграє найкоротший код у байтах. Вибачте, якщо це здається незрозумілим ... Я теж не знаю мов, не запам'ятаю слова добре ... Краще мати одне посилання на Ideone.com чи якесь інше місце, щоб легко спробувати відповідь, особливо для перевірити деякий вхід, відмінний від запропонованого.

05AB1E , 17 13 11 19 14 байт

Введіть у форму b, a, c.
Збережено 5 байт завдяки Grimy .

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

Спробуйте в Інтернеті!

Haskell, 87 байт

(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

Приклад використання: (13#7)27-> "1.857142857142857142857142857".

23 байти для обробки c==0справи та використання провідного нуля замість таких речей .5.

Як це працює: помножте aна 10^c, розділіть на b, перетворіть на рядок, розділіть, куди .потрібно вставити, з'єднайте обидві частини .проміжком і зафіксуйте крайові регістри.

Perl 6 ,  58 57 55  48 байт

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

Що дуже дратує, це те, що його можна було б скоротити до того, {($^a.FatRat/$^b).base(10,$^c)}якби йому було дозволено округлити до найближчого значення.

Пояснення:

# 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 байт

Включає +3 для -p

Дайте a і b на одному рядку на STDIN, c на наступному

division.pl
1 26
38
^D

division.pl:

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

$_/$&трохи суперечливе. Насправді я хочу, щоб там було ціле ділення, але у perl цього немає без завантаження спеціальних модулів. Отже, це тимчасово не ціле число, яке потім негайно обрізаю (використовуючи |0), тому я закінчую ціле число, яке дасть ціле ділення. Це може бути переписано так ($_-$_%$&)/$&, щоб навіть тимчасово не мати ціле значення (воно все-таки все-таки буде плаватим)

JavaScript (ES6), 55 50 байт

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

(a/b|0)виконує поплавковий поділ, але негайно відкидає ціле число. Будь ласка, дайте мені знати, якщо це заборонено.

PHP, 187 байт

працює з рядками для чисельника, які можуть бути значеннями int більше 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);

У мене немає іншого шансу, тоді 13/7 скорочується до 1.8571428571429, і я не знаходжу тестовий випадок з 27 знаками після коми

Таким чином 36 байт заборонено

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

Pyth - 21 19 18 16 14 байт

Буде шукати формат введення, що може заощадити купу.

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

Тестовий сюїт . (PS 27 не закінчується в Інтернеті, тому я зробив 10 замість цього).

JavaScript (ES6),  64  62 59 байт

Збережено 2 байти завдяки ETHproductions.

Включене ділення завжди призводить до цілого числа.

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 байт

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

Невикористаний і тестовий код:

Спробуйте тут.

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

Вихід:

0.5
0.50
1.857142857142857142857142857
0.6
0.8000000
0
434
5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

Рубін, 67 байт

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

якщо я зроблю його функцією для виконання тестових випадків вище

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 

Ракетка 203 байти

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

Безголівки:

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

Використання:

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

Вихід:

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

Інший метод (тут не вірна відповідь):

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

q, 196 байт

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

Для запуску: спочатку встановіть a, b, c.

Іржа, 114 байт

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

код тесту:

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 байт

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

intdiv () вводиться в php 7, тому цього потрібно. php 7.1 дозволив би мені змінити список () на [] і таким чином заощадив би 4 байти.

використовувати як:

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 байт

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

Повна програма з тестовими кейсами:

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

Здійснено поділ цілих чисел. Цифри будь-якого розміру можна використовувати, залежно від BigIntegerтипу даних (імпорт System.Numericsнеобхідний). Параметр підрахунку цифр cобмежений 2 ^ 31-1, однак він повинен містити більше, ніж достатньо цифр.

Groovy (78 77 42 Bytes)

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

Explanation

Eval.me(a+'.0g'); - Convert from integer input to BigDecimal input. In groovy BigDecimal notation is double notation with an appended G or g. I could've also used the constructor new BigDecimal(it) but this saved a byte.
.divide(b, n, 1) - Divide by b with n precision, rounding mode half-up.

Try it here: 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]&

Unnamed function of three arguments (which are ordered c, a, b to save a byte somewhere), which returns a string. It multiplies a/b by 10^c, takes the greatest integer function, then converts to a string and inserts a decimal point at the appropriate spot. Too bad the function names aren't shorter.

Python 3, 62 Bytes

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

Try It Here

*Note: repl.it uses an older ver of Python 3, which requires all field indices to be specified, meaning "{:.{1}f}" will be "{0:.{1}f}" instead, making it 63 bytes in repl.it

How to use

Enter all three values with spaces in-between. i.e. An input of 1 2 1 would give a result of 0.5

Explanation

input().split(): Gets user input and splits it into a list with a separator of (space)

a,b,c = map(int,XX): Maps the variables into the values specified by the user with an int type

"{:.{1}f}".format(a/b,c): Formats a string to display the division result and substitutes {1} with c to set the decimal place of the displayed string

print(XX): prints the string supplied

Python 3, 58 bytes

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

Try it online!

This is precise to the specified number of decimals as long as a * 10 ** c isn't too large.

I tried Python 2 to shorten the str(...) to `...` but Python 2 inserts an L at the end if it's too large so checking for that would take way more bytes than it's worth.

Stax, 13 bytes

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

Run and debug it

Arguments are accepted in c a b order.

C, 67 bytes

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

Try it online!

Some previous version I think had a bug in read memory out of assigned to the program...Thanks to ceilingcat and for all...