ปัดเศษจากศูนย์

แรงบันดาลใจจากรอบต่อศูนย์

ให้การป้อนตัวเลขด้วยวิธีการที่สมเหตุสมผลรอบตัวเลข "ห่างจากศูนย์" - ตัวเลขบวกปัดขึ้นและตัวเลขลบปัดเศษลง

หากคุณตั้งใจจะรับอินพุตเป็นสตริง (เช่น STDIN เป็นต้น) คุณควรจะสามารถจัดการกับตัวเลขที่มีหรือไม่มีจุดทศนิยม หากคุณใช้เป็นตัวเลขอย่างน้อยก็ควรจะสามารถจัดการกับความแม่นยำจุดลอยตัว (ไม่จำเป็นต้องมีความแม่นยำสองครั้ง) หรือจำนวนตรรกยะ

คุณสามารถส่งออกตัวเลขทศนิยมด้วยจุดทศนิยม (เช่น 42.0) หากต้องการ (หรือมีบางกรณีทดสอบเอาท์พุทจุดลอยและจำนวนเต็มเอาท์พุทถ้ามันทำให้คำตอบของคุณสั้นลง)

ไม่อนุญาตช่องโหว่มาตรฐาน ฯลฯ เป็นต้น

กรณีทดสอบ

-99.9 => -100
-33.5 => -34
-7    => -7
-1.1  => -2
0     => 0
2.3   => 3
8     => 8
99.9  => 100
42.0  => 42
-39.0 => -39

ลิงก์ Sandbox

Excel, 13 ไบต์

=ROUNDUP(A1,)

ทางเลือก

=EVEN(A1*2)/2

R, 32 ไบต์

x=scan()
sign(x)*ceiling(abs(x))

เยลลี่ขนาด 4 ไบต์

ĊṠ¡Ḟ

ลิงก์ monadic ยอมรับตัวเลขที่ให้จำนวนเต็ม

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

ĊṠ¡Ḟ - Link: number, N
  ¡  - repeat...
 Ṡ   - ...number of times: sign of N (repeating -1 is the same as 0 times)
Ċ    - ...action: ceiling
   Ḟ - floor (that)

Python 3 , 23 ไบต์

lambda i:i-i%(1|-(i>0))

ลองออนไลน์!

-1 ไบต์ต้องขอบคุณxnor

เยลลี่ , 5 4 ไบต์

AĊ×Ṡ

ลองออนไลน์!

พอร์ตนี้จะตอบคำตอบของ Stax ซ้ำใน Jelly ดังนั้นให้ตรวจสอบคำตอบนั้นเพื่อหาคำอธิบาย

-1 ไบต์ต้องขอบคุณNick Kennedy

เยลลี่ , 6 5 ไบต์

ĊḞ>?0

ลองออนไลน์!

-1 ไบต์ขอบคุณJonathan Allan

วิธีนี้ใช้งานได้

ĊḞ>?0 - Monadic link. Takes a float, x, as argument

   ?  - If:
  > 0 -   x > 0
      - Then:
Ċ     -   ceil(x)
      - Else:
 Ḟ    -   floor(x)

Java (JDK) , 18 ไบต์

d->d.setScale(0,0)

ลองออนไลน์!

คำอธิบาย

ใช้BigDecimalเป็นอินพุตและเอาต์พุต BigDecimalมีวิธีการsetScaleที่กำหนดขนาดของตัวเลข พารามิเตอร์แรกคือจำนวนหลักหลังตัวแยกจุดจุดที่สองคือโหมดการปัดเศษ ROUND_UPคือการปัดเศษ "ห่างจากศูนย์" และมีค่า0ดังนั้นฉันจึงฮาร์ดโค้ดค่านั้น

Vim, 36 bytes/keystrokes

:s/-/-<Space>
:g/\..*[1-9]/norm <C-v><C-a>lD
:s/<Space><cr>

Try it online! or Verify all Test Cases!

Explanation:

:s/             " Replace...
   -            "   A dash
    /-<Space>   "   With a dash and a space

:g/                             " On Every line matching this regex...
   \.                           "   A dot
     .*                         "   Followed By anything
       [1-9]                    "   Followed by a digit other than 0
            /norm               " Run the following keystrokes...
                  <C-v><C-a>    "   Increment the number by 1
                                "   This also conveniently places our cursor just before the dot
                            l   "   Move one character right
                             D  "   Delete everything after the cursor

:s/             " Replace...
   <Space>      "   A space
                "   (With nothing)

J, 6 bytes

**>.@|

Try it online!

Just a 1 character change from my answer on the cousin question.

C# (Visual C# Compiler), 41 bytes27 bytes24 bytes

s=>(int)s+Math.Sign(s%1)

Try it online!

First post here, had fun with it, hope u like it. Kinda felt C# place is empty here

-14 tnx to @expired data
-3 tnx to @night2

Runic Enchantments, 18 16 bytes

1µ-i:'-A{*+'.A@

Try it online!

"Adds" (away from zero) 0.999999 and floors the result. µ is the closest thing to an infinitesimal in language's operators. With a properly functioning Trunc(x) command, answer now supports 0 as input.

Stax, 6 bytes

å├╪∙Bß

Run and debug it

Procedure:

1. Absolute value
2. Ceiling
3. Multiply by original sign

C, 94 43 39 bytes

thanks to ceilingcat for 39 bytes

#define f(n)(int)(n>0?ceil(n):floor(n))

TIO

Retina 0.8.2, 38 bytes

\.0+
.
\b9+\..
0$&
T`9d`d`.9*\..
\..*

Try it online! Link includes test cases. Explanation:

\.0+
.

Delete zeroes after the decimal point, to ensure that the number is not an integer; the next two matches fail if there are no digits after the decimal point.

\b9+\..
0$&

If the integer part is all 9s, prefix a 0 to allow the increment to overflow.

T`9d`d`.9*\..

Increment the integer part of the number.

\..*

Delete the fractional part of the number.

05AB1E, 6 bytes

ÄîI.±*

A 5-byter should definitely be possible..

Try it online or verify all test cases.

Explanation:

Ä       # The absolute value of the (implicit) input,
 î      # ceiled
     *  # And then multiplied by
   .±   # the signum
  I     # of the input
        # (after which the result is output implicitly)

JavaScript (ES6), 20 bytes

n=>n%1?n<0?~-n:-~n:n

Try it online!

Commented

n =>        // n = input
  n % 1 ?   // if n is not an integer:
    n < 0 ? //   if n is negative:
      ~-n   //     return -(floor(-n) + 1) = -floor(-n) - 1
    :       //   else:
      -~n   //     return -(-(floor(n) + 1)) = floor(n) + 1
  :         // else:
    n       //   return n unchanged

Perl 6, 18 bytes

{$_-.abs%-1*.sign}

Try it online!

Explanation

{                }  # Anonymous block
    .abs  # Absolute value
        %-1  # Modulo -1
           *.sign  # Multiply by sign
 $_-  # Subtract from original

MathGolf, 5 bytes

‼σ±ü*

Try it online!

Explanation

It's nice to find usage for the ‼ operator.

‼       apply next two operators to (implicit) input
 σ      sign (-1, 0, or 1)
  ±     absolute value
   ü    ceiling of that absolute value
    *   multiply the rounded absolute value with the sign

PHP, 30 bytes

<?=0^$argn-=0<=>fmod($argn,1);

Try it online!

If number is not integer, based on the sign -1 (for negative decimals) or 1 (for positive decimals) is added to it and then integer part of the new number is printed.

PHP, 32 bytes

<?=[ceil,floor][$argn<0]($argn);

Try it online!

Basically outputs floor of input if it is less than 0, else ceil of it.

PHP, 34 bytes

<?=($argn>0?:-1)*ceil(abs($argn));

Try it online!

Brachylog, 7 bytes

⌋₁ℤ₁|⌉₁

Try it online!

or ⌉₁ℕ₁|⌋₁.

⌋₁         The input rounded down
  ℤ₁       is an integer less than -1
    |      and the output, or, the input
     ⌉₁    rounded up is the output.

Wolfram Language (Mathematica), 18 bytes

Sign@#⌈Abs@#⌉&

Try it online!

Factor, 57 bytes

: f ( x -- x ) [ signum ] [ abs ceiling ] bi * >integer ;

Try it online!

APL (Dyalog Unicode), 15 bytes

{⍎'⌈⌊'[0>⍵],⍕⍵}

Try it online!

Simple Dfn. Uses ⎕IO←0.

How:

{⍎'⌈⌊'[0>⍵],⍕⍵} ⍝ Main function, argument ⍵.
            ⍕⍵  ⍝ Stringified argument
           ,    ⍝ Appended to
      [0>⍵]     ⍝ This item... (0 if ⍵ is positive or 0, else 1)
  '⌈⌊'          ⍝ of this string (which are the functions Ceiling and Floor, respectively)
 ⍎              ⍝ Executed as APL code.

sed, 131 bytes + 2 bytes for -r flag

/^-?[^.]*(\.0*)?$/bQ
s/^(-?)9/\109/
s/([0-8]9*)\..*$/_\1/
h
s/.*_//
y/0123456789/1234567890/
G
s/(.*)\n(.*)_(.*)/\2\1/
:Q
s/\..*$//

Ungolfed

#!/bin/sed -rf

# identify integers
/^-?[^.]*(\.0*)?$/ b isInt

# add a leading 0 if we'll need it later
s/^(-?)9/\109/

# convert to format: -?[0-9]_[0-8]9*
s/([0-8]9*)\..*$/_\1/

# move the part that will remain constant into the hold buffer
h
s/.*_//

# [0-8]9* can be incremented via character substitution
y/0123456789/1234567890/

# reassemble parts
G
s/(.*)\n(.*)_(.*)/\2\1/

:isInt
# Get rid of anything after the decimal point
s/\..*$//

Perl 5 -pF/\./, 35 bytes

$_&&=$F[0]+($_!=int&&$_*(@F-1)/abs)

Try it online!

JavaScript (node.js), 30 23 21 bytes

s=>~~s+Math.sign(s%1)

Inspired by the C# answer.

Thanks to @Value Ink and @Gust van de Wal for -7 bytes!

Thanks again, @Gust van de Wal for another -2 bytes!

Perl 6, 19 bytes

{$_+|0+.sign*?/\./}

Try it online!

Not the shortest solution, but I'm working on it. Basically this truncates the number, then adds one away from zero if the number was not whole to begin with

Java (OpenJDK 8), 43 bytes

a->{return(int)((int)a/a<1?a>0?a+1:a-1:a);}

Try it online!

Japt, 6 bytes

Î*Ua c

Try it here

Red, 46 bytes

func[n][(pick[0 1]n = t: to 0 n)*(sign? n)+ t]

Try it online!

The slightly more readable version is 2 byte longer (those long function names!):

func[n][to 1(sign? n)* round/ceiling absolute n]

Scala, 16 bytes

_.setScale(0,UP)

Try it online!

Scala, 22 bytes

x=>x.signum*x.abs.ceil

Try it online!