양의 정수에 걸리는 프로그램이나 함수를 작성 a, b및 c, 및 인쇄 또는 반환 a/b에 c소수점, + 작업을 사용하여 - 양의 정수에 [는 조절 추가, 빼기, 곱하기, 나누기] * / % : 당신은 모두를 사용할 수 귀하의 언어는 부동 소수점 숫자를 허용하지만 허용하지는 않습니다. a, b, c의 범위는 사용자 언어에서 부호없는 정수에 허용되는 범위입니다. 숫자 결과는 인쇄 할 마지막 숫자로 잘립니다 (그래서 no round).

즉, 언어에 정수 유형이없는 경우 (float 만 해당) 이러한 float 숫자를 양의 정수로만 사용하여 참여할 수 있습니다. 이 연습의 단서는 [부호없는] 정수에서 +-* / % 연산 만 사용하여 부동 소수점 나누기에서 숫자를 찾는 함수를 작성하는 것입니다.

예

• 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

바이트 단위의 가장 짧은 코드가 이깁니다. 이것이 명확하지 않으면 유감입니다. 언어도 모릅니다. 단어를 잘 기억하지 마십시오 ... 제안 된 것과 다른 입력을 테스트하십시오.

05AB1E , 17 13 11 19 14 바이트

형식으로 입력하십시오 b, a, c. Grimy
덕분에 5 바이트를 절약했습니다 .

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

온라인으로 사용해보십시오!

하스켈, 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와 같은 대신 0을 사용합니다 .5.

그것이 작동하는 방법 : 곱셈 a에 10^c의해 나누기 b는이 문자열 분할로 전환 .삽입해야합니다으로 두 부분을 조인 .의 사이 가장자리 케이스를 고정합니다.

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

펄, 55 바이트

에 +3 포함 -p

STDIN에서 한 줄에 a와 b를, 다음 줄에 c를 줘

division.pl
1 26
38
^D

division.pl:

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

는 $_/$&약간의 논쟁의 여지가있다. 실제로 정수 나누기를 원 하지만 특수 모듈을로드하지 않고는 펄이 없습니다. 따라서 일시적으로 정수가 아닌 정수이며 즉시 (을 사용하여 |0) 잘라내어 정수 나누기가주는 정수로 끝납니다. ($_-$_%$&)/$&정수가 아닌 값을 일시적으로 갖지 않기 위해 다시 작성할 수 있습니다 (내부적으로 여전히 부동 소수점 임)

자바 스크립트 (ES6), 55 50 바이트

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

(a/b|0)float 나누기를 수행하지만 즉시 정수로 캐스트합니다. 이것이 허용되지 않는 경우 알려주십시오.

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을했습니다.)

자바 스크립트 (ES6),  64  62 59 바이트

ETH 프로덕션 덕분에 2 바이트를 절약했습니다.

포함 된 나누기는 항상 정수입니다.

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

자바 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에서는 list ()를 []로 변경할 수 있으므로 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로 제한되지만 충분한 자릿수를 제공해야합니다.

그루비 ( 78 77 42 바이트)

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

설명

Eval.me(a+'.0g');-정수 입력에서 BigDecimal 입력으로 변환합니다. groovy에서 BigDecimal 표기법은 G 또는 g가 추가 된 이중 표기법입니다. 생성자를 사용할 수도 new BigDecimal(it)있었지만 바이트가 절약되었습니다.
.divide(b, n, 1)-반올림 모드를 반올림하여 n 정밀도로 b로 나눕니다.

여기에서 시도하십시오 : https://groovyconsole.appspot.com/script/5177545091710976

배치, 122 바이트

@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 바이트

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

(정렬 세 개의 인수의 이름 기능 c, a, b문자열을 반환, 바이트 어딘가에 저장). 이 곱하기 a/b에 10^c가장 큰 정수 함수를 취한 다음 문자열로 변환하여 적절한 지점에 소수점을 삽입합니다. 함수 이름이 짧지 않은 것이 너무 나쁩니다.

파이썬 3, 62 바이트

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

여기 사용해보십시오

* 참고 : repl.it이 버전의 이전 사용 파이썬 3 지정할 수있는 모든 필드 인덱스를 필요로 의미가 "{:.{1}f}"있을 것입니다 "{0:.{1}f}"그것을 만드는 대신 63 바이트 에서 repl.it을

사용하는 방법

사이에 공백이있는 세 값을 모두 입력하십시오. 즉, 입력 1 2 1은0.5

설명

input().split(): 사용자 입력을 가져 와서 (공백)으로 구분 된 목록으로 분할합니다.

a,b,c = map(int,XX): 변수를 int 유형의 사용자가 지정한 값으로 맵핑합니다.

"{:.{1}f}".format(a/b,c): 나누기 결과를 표시하도록 문자열을 형식화 {1}하고c 하고 표시된 문자열의 소수점 이하 자릿수를

print(XX): 제공된 문자열을 인쇄합니다

파이썬 3 , 58 바이트

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

온라인으로 사용해보십시오!

a * 10 ** c너무 크지 않은 한 지정된 소수 자릿수까지 정확합니다 .

나는 파이썬 2를 줄여서 str(...)to를 줄 `...`였지만 파이썬 2는 L너무 큰 경우 끝에를 삽입 하므로 그 값을 확인하는 데 가치가있는 것보다 많은 바이트가 필요합니다.

Stax , 13 바이트

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

실행 및 디버깅

인수는 c a b순서대로 허용됩니다 .

C, 67 바이트

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

온라인으로 사용해보십시오!

이전의 일부 버전은 프로그램에 할당되지 않은 읽기 메모리에 버그가 있다고 생각합니다.