Redondear lejos de cero

Inspirado por Round hacia cero .

Dado un ingreso numérico a través de cualquier método razonable, redondea el número "lejos de cero": los números positivos se redondean hacia arriba y los negativos se redondean hacia abajo.

Si tiene la intención de tomar la entrada como una cadena (a través de STDIN, por ejemplo), debería poder manejar números con o sin el punto decimal. Si lo toma como un número, al menos debería ser capaz de manejar la precisión de punto flotante (no se requiere precisión doble) o números racionales.

Puede generar un número de coma flotante con el punto decimal (por ejemplo, 42.0) si lo desea. (O incluso hacer que algunos casos de prueba generen coma flotante y algún número entero de salida, si acorta su respuesta).

Las lagunas estándar no están permitidas, etc., etc.

Casos de prueba

-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

Enlace de caja de arena

Excel, 13 bytes

=ROUNDUP(A1,)

Alternativa

=EVEN(A1*2)/2

R, 32 bytes

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

Jalea , 4 bytes

ĊṠ¡Ḟ

Un enlace monádico que acepta un número que produce un número entero.

Pruébalo en línea!O ver un conjunto de pruebas .

¿Cómo?

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

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

Pruébalo en línea!

-1 byte gracias a xnor

Jalea , 5 4 bytes

AĊ×Ṡ

Pruébalo en línea!

Esta respuesta Stax recursiva de puertos en Jelly, así que verifique esa respuesta para obtener una explicación.

-1 byte gracias a Nick Kennedy

Jalea , 6 5 bytes

ĊḞ>?0

Pruébalo en línea!

-1 byte gracias a Jonathan Allan

Como funciona este

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

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

Java (JDK) , 18 bytes

d->d.setScale(0,0)

Pruébalo en línea!

Explicaciones

Utiliza a BigDecimalcomo entrada y salida. BigDecimaltiene un método setScaleque establece la escala del número. El primer parámetro es el número de dígitos después del separador de puntos, el segundo es el modo de redondeo. ROUND_UPes el redondeo "lejos de cero" y tiene un valor de 0modo que codifico ese valor.

Vim, 36 bytes / pulsaciones de teclas

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

Pruébalo en línea! o verificar todos los casos de prueba!

Explicación:

: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

**>.@|

Pruébalo en línea!

Solo un cambio de 1 carácter con respecto a mi respuesta a la pregunta del primo .

C # (compilador de Visual C #) , 41 bytes 27 bytes 24 bytes

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

Pruébalo en línea!

Primera publicación aquí, me divertí mucho, espero que les guste. Un poco sintió que el lugar de C # está vacío aquí

-14 tnx a @ datos vencidos
-3 tnx a @ night2

Encantamientos rúnicos , 18 16 bytes

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

Pruébalo en línea!

"Agrega" (lejos de cero) 0.999999 y muestra el resultado. µes lo más parecido a un infinitesimal en los operadores del lenguaje. Con un Trunc(x)comando que funcione correctamente , la respuesta ahora es compatible 0como entrada.

Stax , 6 bytes

å├╪∙Bß

Ejecutar y depurarlo

Procedimiento:

1. Valor absoluto
2. Techo
3. Multiplicar por signo original

C, 94 43 39 bytes

gracias a ceilingcat por 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*\..
\..*

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

\.0+
.

Elimine los ceros después del punto decimal, para asegurarse de que el número no sea un entero; las siguientes dos coincidencias fallan si no hay dígitos después del punto decimal.

\b9+\..
0$&

Si la parte entera es todo 9s, prefija a 0para permitir que el incremento se desborde.

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

Incremente la parte entera del número.

\..*

Eliminar la parte fraccionaria del número.

05AB1E , 6 bytes

ÄîI.±*

Un 5-byter definitivamente debería ser posible.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Pruébalo en línea!

Comentado

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}

Pruébalo en línea!

Explicación

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

MathGolf , 5 bytes

‼σ±ü*

Pruébalo en línea!

Explicación

Es bueno encontrar uso para el ‼operador.

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

Pruébalo en línea!

Si el número no es entero, se le agrega el signo -1 (para decimales negativos) o 1 (para decimales positivos) y luego se imprime una parte entera del nuevo número.

PHP , 32 bytes

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

Pruébalo en línea!

Básicamente salidas floorde entrada si es menor que 0, de lo contrario ceil.

PHP , 34 bytes

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

Pruébalo en línea!

Brachylog , 7 bytes

⌋₁ℤ₁|⌉₁

Pruébalo en línea!

o ⌉₁ℕ₁|⌋₁.

⌋₁         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@#⌉&

Pruébalo en línea!

Factor , 57 bytes

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

Pruébalo en línea!

APL (Dyalog Unicode) , 15 bytes

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

Pruébalo en línea!

Dfn simple. Usos ⎕IO←0.

Cómo:

{⍎'⌈⌊'[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 para -rbandera

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

Sin golf

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

Pruébalo en línea!

JavaScript (node.js), 30 23 21 bytes

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

Inspirado en la respuesta de C #.

¡Gracias a @Value Ink y @Gust van de Wal por -7 bytes!

Gracias de nuevo, @Gust van de Wal por otros -2 bytes.

Perl 6 , 19 bytes

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

Pruébalo en línea!

No es la solución más corta, pero estoy trabajando en ello. Básicamente, esto trunca el número, luego agrega uno lejos de cero si el número no estaba completo para empezar

Java (OpenJDK 8) , 43 bytes

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

Pruébalo en línea!

Japt , 6 bytes

Î*Ua c

Pruébalo aquí

Rojo , 46 bytes

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

Pruébalo en línea!

La versión ligeramente más legible es 2 bytes más larga (¡esos nombres de funciones largos!):

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

Scala , 16 bytes

_.setScale(0,UP)

Pruébalo en línea!

Scala , 22 bytes

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

Pruébalo en línea!