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

code-golf number

— Encre de valeur
source

si nous prenons des nombres dans un contexte de chaîne, tel que STDIN, devons-nous prendre en charge le .0comme les cas de test semblent le suggérer?

— Jo King

@JoKing yes-- Je mettrai à jour la question pour clarifier. C'était en fait le cas d'origine, mais les gens dans le bac à sable ont suggéré d'ajouter des cas de test non décimaux alors euh, nous voici avec les deux, désolé

— Value Ink

Ça fait du bien d'être source d'inspiration :)

— connectyourcharger

C'est drôle que toutes les langues qui ont si bien réussi le défi précédent en prenant une entrée et une sortie entières ne fonctionneront pas si bien, car elles ne peuvent pas faire la différence entre -0.1et0.1

— Jo King

15

Excel, 13 octets

=ROUNDUP(A1,)

Alternative

=EVEN(A1*2)/2

— nwellnhof
source

4

EVEN, quelle fonction étrange ..

— tsh

13

@tsh Je pense que tu veux dire "fonction étrange".

— négatif sept

2

@negativeseven Le nom d'utilisateur est extrait. :-P

— Veky

9

R, 32 octets

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

— Jeu de mots intentionnel
source

3

31 octets - très belle réponse!

— Giuseppe

25 octets

— Robin Ryder

8

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)

— Jonathan Allan
source

Alors, comment fonctionne exactement ¡les nombres négatifs? Je ne pense pas que ce soit documenté

— caird coinheringaahing

1

Ce n'est pas documenté sur le wiki de Jelly, mais la ¡nature répétitive est implémentée avec une for index in range(repetitions)boucle dans le code. range([stop=]-1)est vide car par startdéfaut à 0et par stepdéfaut à 1et "Pour une étape positive, le contenu d'une plage rest déterminé par la formule r[i] = start + step*ioù i >= 0et r[i] < stop." docs

— Jonathan Allan

¡Le comportement de repose sur celui de Python range, et range(-1).__iter__().__next__()lance immédiatement StopIteration.

— Unrelated String

6

Python 3 , 23 octets

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

Essayez-le en ligne!

-1 octet grâce à xnor

— Jitse
source

1

Vous pouvez faire (1|-(i>0))pour enregistrer un octet (1,-1)[i>0].

— xnor

@xnor Belle trouvaille, merci!

— Jitse

Bien joué. Je l'ai eu à 62 octets ಥ_ಥ:g=lambda r:0if r==0 else(int(r)+r/abs(r)if r/int(r)!=1 else r)

— user14492

Qu'est-ce que le «|» avant le '-'?

— William

1

@jaaq J'aime aussi beaucoup cette solution! Mon approche initiale était également de 24 octets.

— Jitse

5

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)

— caird coinheringaahing
source

ĊḞ>?0fonctionnerait comme votre 6.

— Jonathan Allan

1

AĊ×Ṡest 4 et fonctionnellement identique à votre première réponse.

— Nick Kennedy

@NickKennedy et Jonathan, merci pour les suggestions, elles ont été éditées dans

— caird coinheringaahing

5

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.

— Olivier Grégoire
source

5

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)

— DJMcMayhem
source

Utiliser $F-a <esc>au lieu de la première ligne et une macro avec /comme conditionnel à la place de :get :normdonne 29 octets tio.run/##HczBCoJAFEZhWva/QpuLCNbizoxalBXRInqJMpjGCYVwmkx7/…

— Kritixi Lithos

4

J , 6 octets

**>.@|

Essayez-le en ligne!

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

— Jonas
source

4

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

— hessam hedieh
source

1

Bienvenue sur le site et bonne première réponse! J'espère que vous apprécierez Code Golf!

— caird coinheringaahing

27 octets ... Probablement encore quelques-uns à enregistrer

— Expired Data

@Expired, yea nice, ce type de codage était si bizarre à première vue que j'aurais oublié tout ce qui concerne la bibliothèque, pensez à le poster comme réponse

— hessam hedieh

1

@ Night2, tnx pour le commentaire, je n'ai pas tapé la réponse entière, j'ai utilisé la Code golf submissionfonctionnalité , j'ai juste ajouté un peu de mes propres mots à la fin, mais pour éditer j'ai juste changé cette ligne de code, et ur là, j'ai oublié de mettre à jour le lien, ce qui nous ramène à la première étape, pour ne modifier qu'une seule fois, un peu SOLIDE ici, de toute façon, tnx pour l'astuce aussi

— hessam hedieh

1

Vous avez modifié votre lien TIO vers la version 24 octets, mais la ligne de code elle-même est toujours la version 27 octets.

— Value Ink

4

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.

— Draco18s
source

1

@JoKing Oof. Bonne prise. Il fait un divide by inputpour obtenir le "signe" de la valeur d'entrée, qui, bien sûr, se divise par 0 lorsque l'entrée est 0. Il n'y a pas de (bon) moyen de contourner cela pour le moment. Aura besoin de ce commit en premier. Je vais pousser Dennis (avantage secondaire, la réponse deviendra plus courte).

— Draco18s

1

@JoKing Answer se gère désormais 0correctement.

— Draco18s

3

Stax , 6 octets

å├╪∙Bß

Exécuter et déboguer

Procédure:

Valeur absolue
Plafond
Multiplier par signe original

— récursif
source

L'outil que j'utilise dit que c'est 14 octets

— Gust van de Wal

Votre outil n'est probablement pas au courant de l' encodage des caractères stax . Si vous n'êtes toujours pas convaincu, dans la section "Outils", il y a un lien de téléchargement, où vous pouvez réellement télécharger le fichier source et inspecter sa taille par vous-même.

— récursif le

3

C, 94 43 39 octets

merci à plafondcat pour 39 octets

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

TIO

— Girobuz
source

48

— uniquement ASCII

2

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.

— Neil
source

2

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)

— Kevin Cruijssen
source

2

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

— Arnauld
source

I was writing an answer for my 16-byte answer (n=>(~~n-n%1)%1+n) until I found out that my code didn't work for numbers between -1 and 1. You might be able to figure out how to make this work with the last 3 bytes there's left!

— Gust van de Wal

2

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

— nwellnhof
source

2

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

— maxb
source

2

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!

— Night2
source

1

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.

— Unrelated String
source

1

Wolfram Language (Mathematica), 18 bytes

Sign@#⌈Abs@#⌉&

Try it online!

— attinat
source

1

Factor, 57 bytes

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

Try it online!

— Galen Ivanov
source

1

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.

— J. Sallé
source

1

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/\..*$//

— Ray
source

1

Perl 5 `-pF/\./`, 35 bytes

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

Try it online!

— Xcali
source

fails 3.0. For switches, -pF\. is sufficient: the // are optional.

— Oh My Goodness

also 0.0 is true

— Oh My Goodness

Fixed both of those.

— Xcali

1

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!

— Sagittarius
source

Why use += when + will do the trick in this case? -1 byte

— Value Ink

Instead of parseInt(), I'd just use ~~ at the start or another bitwise operator like |0 or ^0 at the end to save another chunk of bytes

— Gust van de Wal

@ValueInk wow, I have no idea why I wrote +=, thx for pointing it out

— Sagittarius

You can still drop the the outer parentheses

— Gust van de Wal

@GustvandeWal oh, I didn't know that! thanks

— Sagittarius

0

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

— Jo King
source

0

Java (OpenJDK 8), 43 bytes

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

Try it online!

— X1M4L
source

3

The lambda function can be written without using an explicit return statement.

— Joel

@Joel is indeed right. And you can save 4 additional bytes changing the (int)a/a<1 to a%1!=0: 30 bytes

— Kevin Cruijssen

There's also the BigDecimal.setScale method that gives excellent results, like my answer demonstrates

— Olivier Grégoire

33 bytes

— ceilingcat

0

Japt, 6 bytes

Î*Ua c

Try it here

— Shaggy
source

0

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]

— Galen Ivanov
source

0

Scala, 16 bytes

_.setScale(0,UP)

Try it online!

Scala, 22 bytes

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

Try it online!

— Soapy
source

Arrondir à zéro

Arrondir à zéro

Cas de test

Excel, 13 octets

Alternative

R, 32 octets

Gelée , 4 octets

Comment?

Python 3 , 23 octets

Gelée , 5 4 octets

Gelée , 6 5 octets

Comment celui-ci fonctionne

Java (JDK) , 18 octets

Explications

Vim, 36 octets / touches

J , 6 octets

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

Enchantements runiques , 18 16 octets

Stax , 6 octets

Procédure:

C, 94 43 39 octets

Retina 0.8.2 , 38 octets

05AB1E , 6 octets

JavaScript (ES6), 20 octets

Commenté

Perl 6, 18 bytes

Explanation

MathGolf, 5 bytes

Explanation

PHP, 30 bytes

PHP, 32 bytes

PHP, 34 bytes

Brachylog, 7 bytes

Wolfram Language (Mathematica), 18 bytes

Factor, 57 bytes

APL (Dyalog Unicode), 15 bytes

How:

sed, 131 bytes + 2 bytes for -r flag

Ungolfed

Perl 5 -pF/\./, 35 bytes

JavaScript (node.js), 30 23 21 bytes

Perl 6, 19 bytes

Java (OpenJDK 8), 43 bytes

Japt, 6 bytes

Red, 46 bytes

Scala, 16 bytes

Scala, 22 bytes

sed, 131 bytes + 2 bytes for `-r` flag

Perl 5 `-pF/\./`, 35 bytes