Làm tròn từ số không

Lấy cảm hứng từ Round về không .

Đưa ra một đầu vào số thông qua bất kỳ phương pháp hợp lý nào, làm tròn số "cách xa số 0" - số dương làm tròn và số âm làm tròn xuống.

Nếu bạn định lấy đầu vào dưới dạng một chuỗi (ví dụ thông qua STDIN), bạn sẽ có thể xử lý các số có hoặc không có dấu thập phân. Nếu bạn lấy nó làm số, ít nhất nó có thể xử lý độ chính xác của dấu phẩy động (không yêu cầu độ chính xác kép) hoặc số hữu tỷ.

Bạn có thể xuất số dấu phẩy động với dấu thập phân (ví dụ 42.0) nếu muốn. (Hoặc thậm chí có một số trường hợp kiểm tra đầu ra dấu phẩy động và một số nguyên đầu ra, nếu nó làm cho câu trả lời của bạn ngắn hơn.)

Lỗ hổng tiêu chuẩn không được phép, vv

Các trường hợp thử nghiệm

-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

Liên kết hộp cát

Excel, 13 byte

=ROUNDUP(A1,)

Thay thế

=EVEN(A1*2)/2

R, 32 byte

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

Thạch , 4 byte

ĊṠ¡Ḟ

Một liên kết đơn âm chấp nhận một số mang lại một số nguyên.

Hãy thử trực tuyến! Hoặc xem một bộ thử nghiệm .

Làm sao?

ĊṠ¡Ḟ - 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 byte

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

Hãy thử trực tuyến!

-1 byte nhờ xnor

Thạch , 5 4 byte

AĊ×Ṡ

Hãy thử trực tuyến!

Cổng này đệ quy câu trả lời Stax của Jelly vào Jelly, vì vậy hãy kiểm tra câu trả lời đó để được giải thích.

-1 byte nhờ Nick Kennedy

Thạch , 6 5 byte

ĊḞ>?0

Hãy thử trực tuyến!

-1 byte nhờ Jonathan Allan

Cái này hoạt động thế nào

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

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

Java (JDK) , 18 byte

d->d.setScale(0,0)

Hãy thử trực tuyến!

Giải thích

Sử dụng BigDecimalnhư là đầu vào và đầu ra. BigDecimalcó một phương pháp setScaleđặt tỷ lệ của số. Tham số đầu tiên là số chữ số sau dấu phân cách dấu chấm, thứ hai là chế độ làm tròn. ROUND_UPlà làm tròn "từ xa" và có giá trị 0vì vậy tôi mã hóa giá trị đó.

Vim, 36 byte / tổ hợp phím

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

Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm!

Giải trình:

: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 byte

**>.@|

Hãy thử trực tuyến!

Chỉ cần thay đổi 1 ký tự từ câu trả lời của tôi về câu hỏi anh em họ .

C # (Trình biên dịch C # Visual) , 41 byte 27 byte 24 byte

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

Hãy thử trực tuyến!

Bài viết đầu tiên ở đây, vui vẻ với nó, hy vọng bạn thích nó. Kinda cảm thấy nơi C # trống ở đây

-14 tnx đến @ dữ liệu đã hết hạn
-3 tnx đến @ night2

Runic bùa mê , 18 16 byte

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

Hãy thử trực tuyến!

"Thêm" (cách xa 0) 0.999999 và kết quả. µlà điều gần gũi nhất với các nhà khai thác ngôn ngữ. Với một Trunc(x)lệnh hoạt động đúng , trả lời bây giờ hỗ trợ 0như đầu vào.

Stax , 6 byte

å├╪∙Bß

Chạy và gỡ lỗi nó

Thủ tục:

1. Giá trị tuyệt đối
2. Trần nhà
3. Nhân với dấu hiệu ban đầu

C, 94 43 39 byte

nhờ trần nhà cho 39 byte

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

TIO

Võng mạc 0.8.2 , 38 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

\.0+
.

Xóa các số 0 sau dấu thập phân, để đảm bảo rằng số đó không phải là số nguyên; hai trận đấu tiếp theo sẽ thất bại nếu không có chữ số nào sau dấu thập phân.

\b9+\..
0$&

Nếu phần nguyên là tất cả 9s, tiền tố a0 để cho phép gia tăng tràn.

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

Tăng phần nguyên của số.

\..*

Xóa phần phân số của số.

05AB1E , 6 byte

ÄîI.±*

Một 5 -terter chắc chắn là có thể ..

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Ä       # 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 byte

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

Hãy thử trực tuyến!

Đã bình luận

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 byte

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

Hãy thử trực tuyến!

Giải trình

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

MathGolf , 5 byte

‼σ±ü*

Hãy thử trực tuyến!

Giải trình

Thật tuyệt khi tìm thấy cách sử dụng cho các ‼nhà điều hành.

‼       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 byte

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

Hãy thử trực tuyến!

Nếu số không phải là số nguyên, dựa trên dấu -1 (đối với số thập phân âm) hoặc 1 (đối với số thập phân dương) được thêm vào số đó và sau đó phần nguyên của số mới được in.

PHP , 32 byte

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

Hãy thử trực tuyến!

Về cơ bản đầu ra floorcủa đầu vào nếu nó nhỏ hơn 0, khác ceilvới nó.

PHP , 34 byte

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

Hãy thử trực tuyến!

Brachylog , 7 byte

⌋₁ℤ₁|⌉₁

Hãy thử trực tuyến!

hoặc ⌉₁ℕ₁|⌋₁.

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

Ngôn ngữ Wolfram (Mathicala) , 18 byte

Sign@#⌈Abs@#⌉&

Hãy thử trực tuyến!

Yếu tố , 57 byte

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 15 byte

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

Hãy thử trực tuyến!

Dfn đơn giản. Công dụng ⎕IO←0.

Làm sao:

{⍎'⌈⌊'[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 byte + 2 byte cho -rcờ

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

Bị đánh cắp

#!/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 byte

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

Hãy thử trực tuyến!

JavaScript (node.js), 30 23 21 byte

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

Lấy cảm hứng từ câu trả lời C #.

Cảm ơn @Value Ink và @Gust van de Wal cho -7 byte!

Cảm ơn một lần nữa, @Gust van de Wal cho -2 byte khác!

Perl 6 , 19 byte

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

Hãy thử trực tuyến!

Không phải là giải pháp ngắn nhất, nhưng tôi đang nghiên cứu nó. Về cơ bản, điều này cắt bớt số, sau đó thêm một số từ 0 nếu số đó không còn nguyên để bắt đầu

Java (OpenJDK 8) , 43 byte

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

Hãy thử trực tuyến!

Japt , 6 byte

Î*Ua c

Hãy thử nó ở đây

Màu đỏ , 46 byte

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

Hãy thử trực tuyến!

Phiên bản dễ đọc hơn một chút dài hơn 2 byte (những tên hàm dài đó!):

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

Scala , 16 byte

_.setScale(0,UP)

Hãy thử trực tuyến!

Scala , 22 byte

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

Hãy thử trực tuyến!