Arrondir à zéro

Inspiré par Round vers zéro .

Étant donné une entrée de nombre via toute méthode raisonnable, arrondissez le nombre «loin de zéro» - les nombres positifs arrondissent et les nombres négatifs arrondissent vers le bas.

Si vous avez l'intention de prendre l'entrée sous forme de chaîne (via STDIN, par exemple), vous devriez pouvoir gérer les nombres avec ou sans le point décimal. Si vous le prenez comme un nombre, il devrait au moins être capable de gérer la précision en virgule flottante (double précision non requise) ou les nombres rationnels.

Vous pouvez sortir un nombre à virgule flottante avec le point décimal (par exemple 42,0) si vous le souhaitez. (Ou même avoir des cas de test en sortie en virgule flottante et un certain nombre en sortie, si cela rend votre réponse plus courte.)

Les échappatoires standard ne sont pas autorisées, etc., etc.

Cas de test

-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

Lien Sandbox

Excel, 13 octets

=ROUNDUP(A1,)

Alternative

=EVEN(A1*2)/2

R, 32 octets

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

Gelée , 4 octets

ĊṠ¡Ḟ

Un lien monadique acceptant un nombre qui donne un entier.

Essayez-le en ligne! Ou voir un suite de tests .

Comment?

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

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

Essayez-le en ligne!

-1 octet grâce à xnor

Gelée , 5 4 octets

AĊ×Ṡ

Essayez-le en ligne!

Cette réponse récursive Stax de ports dans Jelly, alors vérifiez cette réponse pour une explication.

-1 octet grâce à Nick Kennedy

Gelée , 6 5 octets

ĊḞ>?0

Essayez-le en ligne!

-1 octet merci à Jonathan Allan

Comment celui-ci fonctionne

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

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

Java (JDK) , 18 octets

d->d.setScale(0,0)

Essayez-le en ligne!

Explications

Utilise une BigDecimalentrée et une sortie. BigDecimala une méthodesetScale qui définit l'échelle du nombre. Le premier paramètre est le nombre de chiffres après le séparateur de points, le second est le mode d'arrondi. ROUND_UPest l'arrondi "loin de zéro" et a une valeur 0donc je coder en dur cette valeur.

Vim, 36 octets / touches

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

Essayez-le en ligne!ou Vérifiez tous les cas de test!

Explication:

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

**>.@|

Essayez-le en ligne!

Juste un changement de 1 caractère par rapport à ma réponse à la question du cousin .

C # (Visual C # Compiler) , 41 octets 27 octets 24 octets

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

Essayez-le en ligne!

Premier post ici, amusez-vous avec, j'espère que vous l'aimez. J'ai senti que la place C # est vide ici

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

Enchantements runiques , 18 16 octets

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

Essayez-le en ligne!

"Ajoute" (à partir de zéro) 0,999999 et planifie le résultat. µest la chose la plus proche d'une infinitésimale dans les opérateurs de langage. Avec une Trunc(x)commande fonctionnant correctement , la réponse prend désormais en charge 0en entrée.

Stax , 6 octets

å├╪∙Bß

Exécuter et déboguer

Procédure:

1. Valeur absolue
2. Plafond
3. Multiplier par signe original

C, 94 43 39 octets

merci à plafondcat pour 39 octets

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

TIO

Retina 0.8.2 , 38 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

\.0+
.

Supprimez les zéros après la virgule décimale, pour vous assurer que le nombre n'est pas un entier; les deux correspondances suivantes échouent s'il n'y a pas de chiffres après la virgule décimale.

\b9+\..
0$&

Si la partie entière est entièrement 9s, préfixez a 0pour permettre à l'incrément de déborder.

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

Incrémentez la partie entière du nombre.

\..*

Supprimez la partie fractionnaire du nombre.

05AB1E , 6 octets

ÄîI.±*

Un 5 octets devrait certainement être possible.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne!

Commenté

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!