일부 십진수는 이진 부동 소수점의 내부 표현으로 인해 이진 부동 소수점으로 정확하게 표현 될 수 없습니다. 예를 들어 14.225를 소수점 이하 두 자리로 반올림하면 14.23이 아니라 14.22가됩니다.

파이썬 :

In: round(14.225, 2)
Out: 14.22

그러나 '14 .225 '로 14.225의 문자열 표현이 있다고 가정하면 원하는 반올림 '14 .23'을 문자열 표현으로 얻을 수 있어야합니다.

이 방법은 임의의 정밀도로 일반화 할 수 있습니다.

가능한 파이썬 2/3 솔루션

import sys

def round_string(string, precision):
    assert(int(precision) >= 0)
    float(string)

    decimal_point = string.find('.')
    if decimal_point == -1:
        if precision == 0:
            return string
        return string + '.' + '0' * precision

    all_decimals = string[decimal_point+1:]
    nb_missing_decimals = precision - len(all_decimals)
    if nb_missing_decimals >= 0:
        if precision == 0:
            return string[:decimal_point]
        return string + '0' * nb_missing_decimals

    if int(all_decimals[precision]) < 5:
        if precision == 0:
            return string[:decimal_point]
        return string[:decimal_point+precision+1]

    sign = '-' if string[0] == '-' else '' 
    integer_part = abs(int(string[:decimal_point]))
    if precision == 0:
        return sign + str(integer_part + 1)
    decimals = str(int(all_decimals[:precision]) + 1)
    nb_missing_decimals = precision - len(decimals)
    if nb_missing_decimals >= 0:
        return sign + str(integer_part) + '.' + '0' * nb_missing_decimals + decimals
    return sign + str(integer_part + 1) + '.' + '0' * precision

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

사용법 :

     # No IEEE 754 format rounding
In:  round_string('14.225',2)
Out: '14.23'

     # Trailing zeros
In:  round_string('123.4',5)
Out: '123.40000'

In: round_string('99.9',0)
Out: '100'

    # Negative values
In: round_string('-99.9',0)
Out: '-100'

In: round_string('1',0)
Out: '1'

    # No unnecessary decimal point
In: round_string('1.',0)
Out: '1'

    # No unnecessary decimal point
In: round_string('1.0',0)
Out: '1'

In:  for i in range(8): 
         print(round_string('123456789.987654321',i))
Out: 123456790
     123456790.0
     123456789.99
     123456789.988
     123456789.9877
     123456789.98765
     123456789.987654
     123456789.9876543

직무

입력 인수 1 : 포함하는 문자열

• 하나 이상의 자리 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
• 소수점 이하 자릿수 ( .)는 하나 이상이어야하며
• -첫 문자 인 선택적인 빼기 ( ).

입력 인수 2 : 음이 아닌 정수

출력 : 올바르게 반올림 된 (기본 10) 문자열

반올림 = 반에서 0으로 반올림

이것은 code-golf 입니다. 가장 적은 바이트 수가 이깁니다!

APL (Dyalog) , 4 바이트

Dyalog APL은 충분한 내부 정밀도를 사용합니다.

⎕⍕⍎⍞

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

⍎⍞ 문자열 입력을 실행

⎕⍕ 숫자 입력을 받아서 형식을 지정할 때 정밀도로 사용

펄, 22 20 바이트

printf"%.*f",pop,pop

사용 :

perl -e 'printf"%.*f",pop,pop' 123456789.987654321 3

Dada의 코드 버전입니다. 이전:

printf"%*2\$.*f",@ARGV

PHP, 33 31 바이트

PHP도 올바르게 반올림합니다 (적어도 64 비트).

printf("%.$argv[2]f",$argv[1]);

명령 행 인수에서 입력을받습니다. 로 실행하십시오 -r.

PHP, 내장되지 않음, 133 바이트

[,$n,$r]=$argv;if($p=strpos(_.$n,46))for($d=$n[$p+=$r],$n=substr($n,0,$p-!$r);$d>4;$n[$p]=(5+$d=$n[$p]-4)%10)$p-=$n[--$p]<"/";echo$n;

온라인으로 실행 -nr하거나 테스트하십시오 .

고장

[,$n,$r]=$argv;             // import arguments
if($p=strpos(_.$n,46))      // if number contains dot
    for($d=$n[$p+=$r],          // 1. $d= ($r+1)-th decimal 
        $n=substr($n,0,$p-!$r); // 2. cut everything behind $r-th decimal
        $d>4;                   // 3. loop while previous decimal needs increment
        $n[$p]=(5+$d=$n[$p]-4)%10   // B. $d=current digit-4, increment current digit
    )
        $p-=$n[--$p]<"/";           // A. move cursor left, skip dot
echo$n;

널 바이트가 작동하지 않습니다. 그래서 사용해야 substr합니다.

루비 2.3, 12 + 45 = 57

BigDecimal내장 기능을 사용 하지만 사용하기 전에 필요하므로 플래그로 사용하는 것이 더 저렴합니다.

깃발: -rbigdecimal

함수:

->(s,i){BigDecimal.new(s).round(i).to_s('f')}

루비 2.3은 기본적으로 ROUND_HALF_UP

자바 스크립트 (ES6), 44 바이트

n=>p=>(Math.round(n*10**p)/10**p).toFixed(p)

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

const f = n=>p=>(Math.round(n*10**p)/10**p).toFixed(p)

console.log(f('14.225')(2));

[...Array(8).keys()].map(i=>console.log(f('123456789.987654321')(i)))

console.log(f('123.4')(5))

파이썬 114 105 103 96 91 89 바이트

Kevin Cruijssen 덕분에 5 바이트 절약 Krazor
덕분에 2 바이트 절약

from decimal import*
d=Decimal
lambda x,y:d(x).quantize(d('0.'[y>0]+'1'*y),ROUND_HALF_UP)

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

REXX, 24 바이트

arg n p
say format(n,,p)

REXX는 항상 숫자의 텍스트 표현을 사용하므로 올바른 숫자 반올림은 무료입니다.

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

BASH, 26 23 21 바이트

bc<<<"scale=$2;$1/1"

용법

round_string.sh에 저장, chmod + x round_string.sh

./round_string.sh 23456789.987654321 3

편집 : 라이브러리를로드 할 필요가 없습니다

AHK, 25 바이트

a=%1%
Send % Round(a,%2%)

변수 이름이나 숫자를 받아들이는 함수에서 AHK가 전달 된 매개 변수를 직접 사용할 수 없다는 사실에 다시 한 번 강조합니다. 내가 교체하는 경우 a와 1에 Round기능, 그것은 값을 사용합니다 1. 내가하려고하면 %1%, 그것은 첫 번째 인수의 사용하려고 내용을 일을하지 않는 변수 이름으로. 다른 변수로 설정 해야하는 데 6 바이트가 소요되었습니다.

배치, 390 바이트

@echo off
set s=%1
set m=
if %s:~,1%==- set m=-&set s=%s:~1%
set d=%s:*.=%
if %d%==%s% (set d=)else call set s=%%s:.%d%=%%
for /l %%i in (0,1,%2)do call set d=%%d%%0
call set/ac=%%d:~%2,1%%/5
call set d=00%s%%%d:~,%2%%
set z=
:l
set/ac+=%d:~-1%
set d=%d:~,-1%
if %c%==10 set c=1&set z=%z%0&goto l
set d=%m%%d:~2%%c%%z%
if %2==0 (echo %d%)else call echo %%d:~,-%2%%.%%d:~-%2%%

설명. 해당되는 경우 부호를 추출하여 시작합니다. 그런 다음 숫자를 정수와 분수로 나눕니다. 분수는 숫자 n+1보다 큰 n숫자 를 갖도록 0으로 채워집니다 . n번째 (제로 인덱스)는 숫자 5에 의해 분할하고,이 초기 캐리이다. 정수와 n분수가 연결되고 캐리는 문자별로 추가됩니다. 캐리지 리플이 멈춘 후 숫자가 재구성되고 소수점이 삽입됩니다.

TI 기본, 53 16 바이트

TI-Basic은 IEEE를 사용하지 않으며 아래 방법은 0-9 (포함) 10 진수 위치에서 작동합니다.

Prompt Str1,N
toString(round(expr(Str1),N

CE calcs의 성능을 보여준 @JulianLachniet에게 감사합니다 toString( 내가 알지 못하는 명령이 (Color Edition calcs OS 5.2 이상이 필요합니다).

추신 : 나는 두 번째 줄을 가지고 sub(Str1,1,N+inString(Str1,".있었지만 쓸모가 없다는 것을 깨달았습니다.

자바 7, 77 72 71 바이트

<T>T c(T n,int d){return(T)"".format("%."+d+"f",new Double(n+""));}

덕분에 -1 바이트 @cliffroot

72 바이트 답변 :

String c(String n,int d){return n.format("%."+d+"f",new Double(n));}

Python과 달리 Java는 이미 올바르게 반올림하고 사용할 때 이미 문자열을 반환합니다. String.format("%.2f", aDouble) 와 함께 2당신이 원하는 소수의 양으로 대체.

편집 / 참고 : 예, new Float(n)1 바이트보다 짧다는 것을 알고 new Double(n)있지만 테스트 사례에서는 실패합니다 123456789.987654321.Double vs Float에 관한이 테스트 코드를 참조하십시오.

설명:

<T> T c(T n, int d){               // Method with generic-T & integer parameters and generic-T return-type (generic-T will be String in this case)
  return (T)"".format("%."+d+"f",  //  Return the correctly rounded output as String
    new Double(n+""));             //  After we've converted the input String to a decimal
}                                  // End of method

테스트 코드 :

여기에서 시도하십시오.

class M{
  static <T>T c(T n,int d){return(T)"".format("%."+d+"f",new Double(n+""));}

  public static void main(String[] a){
    System.out.println(c("14.225", 2));
    System.out.println(c("123.4", 5));
    System.out.println(c("99.9", 0));
    System.out.println(c("-99.9", 0));
    System.out.println(c("1", 0));
    System.out.println(c("1.", 0));
    System.out.println(c("1.0", 0));
    for(int i = 0; i < 8; i++){
      System.out.println(c("123456789.987654321", i));
    }
  }
}

산출:

14.23
123.40000
100
-100
1
1
1
123456790
123456790.0
123456789.99
123456789.988
123456789.9877
123456789.98765
123456789.987654
123456789.9876543

파이썬 (2/3), 394 바이트

def rnd(s,p):
    m=s[0]=='-'and'-'or''
    if m:s=s[1:]
    d=s.find('.')
    l=len(s)
    if d<0:
        if p>0:d=l;l+=1;s+='.'
        else:return m+s
    e=(d+p+1)-l
    if e>0:return m+s+'0'*e
    o=''
    c=0
    for i in range(l-1,-1,-1):
        x=s[i]
        if i<=d+p:
            if i!=d:
                n=int(x)+c
                if n>9:n=0;c=1 
                else:c=0
                o+=str(n)
            else:
                if p>0:o+=x
        if i==d+p+1:c=int(x)>4
    if c:o+='1'
    return m+''.join(reversed(o))

임의의 정밀도 숫자에 사용됩니다.

자바 스크립트 (ES6), 155 바이트

(s,n)=>s.replace(/(-?\d+).?(.*)/,(m,i,d)=>i+'.'+(d+'0'.repeat(++n)).slice(0,n)).replace(/([0-8]?)([.9]*?)\.?(.)$/,(m,n,c,r)=>r>4?-~n+c.replace(/9/g,0):n+c)

설명 : 문자열이 처음으로 포함하도록 정규화 .및 n+1소수점 자리. 그런 다음 후행 숫자, 선행 9s 또는 .s 및 모든 선행 숫자가 고려됩니다. 마지막 숫자가 5보다 작은 경우 숫자와 바로 앞의 숫자는 .단순히 제거되지만 5보다 큰 경우 9s가 s로 변경되고 0이전 숫자가 증가합니다 (또는 이전 숫자가 없으면 1이 앞에옵니다).

Python 3 + SymPy, 54 바이트

from sympy import*
lambda s,p:'%.*f'%(p,S(s).round(p))

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

스칼라, 44 바이트

(s:String,p:Int)=>s"%.${p}f"format s.toFloat

테스트:

scala> var x = (s:String,p:Int)=>s"%.${p}f"format s.toFloat
x: (String, Int) => String = <function2>

scala> x("14.225",2)
res13: String = 14.23

Wonder , 10 바이트

@@fix#1E#0

용법:

@@fix#1E#0

필요한 경우 십진 정밀도를 설정하고 후행 0을 추가하십시오.

J, 22 17 바이트

((10 j.[)]@:":".)

NB.    2    ((10 j.[)]@:":".)   '12.45678'
NB.    12.46 

규칙에 대한 이해를 수정 한 @Conor O'Brien에게 감사합니다.

t=:4 :'(10 j.x)":".y'

    NB.    Examples
    NB.    4 t'12.45678'
    NB.    12.4568
    NB.    4 t'12.456780'
    NB.    12.4568
    NB.    4 t'12.4567801'
    NB.    12.4568
    NB.    2 t'12.45678'
    NB.      12.46
    NB.    2 t'12.4567801'
    NB.      12.46
    NB.    2 (10 j.[)":". '_12.4567801'
    NB.     _12.46

format    
    x t y
where x is a digit number of decimal places required and y
is the character string containing the value to be rounded.