Arrotondare da zero

Ispirato da Round verso lo zero .

Dato un input numerico tramite qualsiasi metodo ragionevole, arrotondare il numero "lontano da zero" - numeri positivi arrotondano per eccesso e numeri negativi arrotondano per difetto.

Se si intende prendere l'input come stringa (ad esempio tramite STDIN), si dovrebbe essere in grado di gestire i numeri con o senza il punto decimale. Se lo prendi come numero, dovrebbe almeno essere in grado di gestire la precisione in virgola mobile (doppia precisione non richiesta) o numeri razionali.

Se lo si desidera, è possibile emettere un numero in virgola mobile con il punto decimale (ad es. 42.0). (O anche alcuni casi di test hanno un output in virgola mobile e alcuni interi di output, se rende la risposta più breve.)

Non sono ammesse scappatoie standard, ecc. Ecc.

Casi 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

Link sandbox

code-golf number

— Value Ink
fonte

se prendiamo numeri in un contesto di stringhe, come STDIN, dobbiamo supportarlo .0come sembrano suggerire i casi di test?

— Jo King,

@JoKing sì-- Aggiornerò la domanda per chiarire. Questo era in realtà il caso originale, ma poi le persone nella sandbox hanno suggerito di aggiungere casi di test non decimali, quindi eccoci qui con entrambi, scusate

— Value Ink

Sembra bello essere d'ispirazione :)

— connectyourcharger

È divertente che tutte le lingue che hanno funzionato così bene nella sfida precedente prendendo l'input intero e l'output intero non funzionino così bene, dal momento che non possono dire la differenza tra -0.1e0.1

— Jo King,

15

Excel, 13 byte

=ROUNDUP(A1,)

Alternativa

=EVEN(A1*2)/2

— nwellnhof
fonte

4

EVEN, che strana funzione ..

— tsh

13

@tsh Penso che intendi "strana funzione".

— negativo sette

2

@negativeseven Nome utente verificato. :-P

— Veky

9

R, 32 byte

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

— Punintended
fonte

3

31 byte - risposta molto bella!

— Giuseppe,

25 byte

— Robin Ryder,

8

Gelatina , 4 byte

ĊṠ¡Ḟ

Un collegamento monadico che accetta un numero che produce un numero intero.

Provalo online! O vedi una suite di test .

Come?

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

— Jonathan Allan
fonte

Quindi, come funziona esattamente ¡per i numeri negativi? Non credo sia documentato

— caird coinheringaahing il

1

Non è documentato sul wiki di Jelly, ma ¡la natura ripetitiva è implementata con un for index in range(repetitions)ciclo nel codice. range([stop=]-1)è vuoto poiché l' startimpostazione predefinita è 0e l' stepimpostazione predefinita è 1e "Per un passaggio positivo, i contenuti di un intervallo rsono determinati dalla formula r[i] = start + step*idove i >= 0e r[i] < stop." docs

— Jonathan Allan,

¡Il comportamento si basa su quello di Python rangee range(-1).__iter__().__next__()si lancia immediatamente StopIteration.

— Unrelated String

6

Python 3 , 23 byte

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

Provalo online!

-1 byte grazie a xnor

— Jitse
fonte

1

Puoi fare (1|-(i>0))per salvare un byte fuori (1,-1)[i>0].

— xnor

@xnor Bella scoperta, grazie!

— Jitse il

Molto bene. L'ho avuto a 62 byte ಥ_ಥ:g=lambda r:0if r==0 else(int(r)+r/abs(r)if r/int(r)!=1 else r)

— user14492

Che cos'è il '|' prima di '-'?

— William,

1

@jaaq Mi piace molto anche quella soluzione! Anche il mio approccio iniziale era di 24 byte.

— Jitse,

5

Gelatina , 5 4 byte

AĊ×Ṡ

Provalo online!

Questo porta la risposta Stax ricorsiva a Jelly, quindi controlla quella risposta per una spiegazione.

-1 byte grazie a Nick Kennedy

Gelatina , 6 5 byte

ĊḞ>?0

Provalo online!

-1 byte grazie a Jonathan Allan

Come funziona questo

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

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

— caird coinheringaahing
fonte

ĊḞ>?0funzionerebbe come fa il tuo 6.

— Jonathan Allan,

1

AĊ×Ṡè 4 e funzionalmente identico alla tua prima risposta.

— Nick Kennedy,

@NickKennedy e Jonathan, grazie per i suggerimenti, sono stati modificati in

— caird coinheringaahing

5

Java (JDK) , 18 byte

d->d.setScale(0,0)

Provalo online!

spiegazioni

Utilizza un BigDecimalinput e un output. BigDecimalha un metodo setScaleche imposta la scala del numero. Il primo parametro è il numero di cifre dopo il separatore di punti, il secondo è la modalità di arrotondamento. ROUND_UPè l'arrotondamento "lontano da zero" e ha un valore di 0così ho hardcode quel valore.

— Olivier Grégoire
fonte

5

Vim, 36 byte / sequenze di tasti

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

Provalo online! o Verifica tutti i casi di test!

Spiegazione:

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

Utilizzando al $F-a <esc>posto della prima riga e una macro con /come condizionale al posto di :ge :normdà 29 byte tio.run/##HczBCoJAFEZhWva/QpuLCNbizoxalBXRInqJMpjGCYVwmkx7/…

— Kritixi Lithos

4

J , 6 byte

**>.@|

Provalo online!

Solo un cambio di 1 carattere dalla mia risposta alla domanda del cugino .

— Giona
fonte

4

C # (compilatore Visual C #) , 41 byte 27 byte 24 byte

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

Provalo online!

Primo post qui, divertiti, spero ti piaccia. Kinda ha sentito che il posto C # è vuoto qui

Da -14 tnx ai dati
@ scaduti -3 tnx a @ night2

— Hessam Hedieh
fonte

1

Benvenuti nel sito e bella prima risposta! Spero ti piaccia Code Golf!

— caird coinheringaahing

27 byte ... Probabilmente ancora pochi da salvare

— Dati scaduti

@Expired, yea nice, questo tipo di codifica è stato così strano a prima vista che sembra che mi sia dimenticato di tutto ciò che è in biblioteca, ricordati di pubblicarlo come risposta

— hessam hedieh

1

@ Night2, tnx per il commento, non ho digitato l'intera risposta, ho usato la Code golf submissionfunzionalità , ho appena aggiunto un po 'delle mie parole alla fine, ma per la modifica ho appena cambiato quella riga di codice e, proprio lì, mi sono dimenticato di aggiorna il link, che ci riporta al primo passo, per modificare solo una volta, un po 'SOLIDI qui, comunque, grazie anche per il suggerimento

— hessam hedieh

1

Hai modificato il tuo collegamento TIO alla versione a 24 byte, ma la stessa riga di codice è ancora la versione a 27 byte.

— Value Ink

4

Incantesimi runici , 18 16 byte

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

Provalo online!

"Aggiunge" (lontano da zero) 0.999999 e pavimenta il risultato. µè la cosa più vicina a un infinitesimale negli operatori del linguaggio. Con un Trunc(x)comando correttamente funzionante , la risposta ora supporta 0come input.

— Draco18s
fonte

1

@JoKing Oof. Buona pesca. Sta facendo un divide by inputper ottenere il "segno" del valore di input, che ovviamente si divide per 0 quando l'input è 0. In questo momento non c'è modo (buono) di aggirarlo. Sarà necessario prima questo impegno . Prenderò in giro Dennis (vantaggio secondario, la risposta sarà più breve).

— Draco18s

1

@JoKing Answer ora gestisce 0correttamente.

— Draco18s

3

Stax , 6 byte

å├╪∙Bß

Esegui ed esegui il debug

Procedura:

Valore assoluto
Soffitto
Moltiplicare per il segno originale

— ricorsivo
fonte

Lo strumento che sto usando dice che questo è 14 byte

— Gust van de Wal

Il tuo strumento probabilmente non è a conoscenza della codifica dei caratteri stax . Se non sei ancora convinto, nella sezione "Strumenti", c'è un link per il download, dove puoi effettivamente scaricare il file di origine e controllarne le dimensioni.

— ricorsivo il

3

C, 94 43 39 byte

grazie a ceilingcat per 39 byte

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

TIO

— girobuz
fonte

48

— ASCII il

2

Retina 0.8.2 , 38 byte

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

Provalo online! Il link include casi di test. Spiegazione:

\.0+
.

Elimina gli zeri dopo il punto decimale, per garantire che il numero non sia un numero intero; le successive due partite falliscono se non ci sono cifre dopo il punto decimale.

\b9+\..
0$&

Se la parte intera è tutta 9s, aggiungere a 0per consentire l'incremento dell'overflow.

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

Incrementa la parte intera del numero.

\..*

Elimina la parte frazionaria del numero.

— Neil
fonte

2

05AB1E , 6 byte

ÄîI.±*

Un 5-byte dovrebbe essere sicuramente possibile.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

2

JavaScript (ES6), 20 byte

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

Provalo online!

Commentate

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
fonte

Stavo scrivendo una risposta per la mia risposta a 16 byte ( n=>(~~n-n%1)%1+n) fino a quando non ho scoperto che il mio codice non funzionava per i numeri tra -1 e 1. Potresti essere in grado di capire come farlo funzionare con gli ultimi 3 byte sinistra!

— Gust van de Wal,

2

Perl 6 , 18 byte

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

Provalo online!

Spiegazione

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

— nwellnhof
fonte

2

MathGolf , 5 byte

‼σ±ü*

Provalo online!

Spiegazione

È bello trovare un utilizzo per l' ‼operatore.

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

2

PHP , 30 byte

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

Provalo online!

Se il numero non è intero, in base al segno -1 (per i decimali negativi) o 1 (per i decimali positivi) viene aggiunto ad esso e quindi viene stampata la parte intera del nuovo numero.

PHP , 32 byte

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

Provalo online!

Fondamentalmente genera floorinput se è inferiore a 0, altrimenti ceil.

PHP , 34 byte

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

Provalo online!

— night2
fonte

1

Brachylog , 7 byte

⌋₁ℤ₁|⌉₁

Provalo online!

oppure ⌉₁ℕ₁|⌋₁.

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

— Stringa non correlata
fonte

1

Wolfram Language (Mathematica), 18 bytes

Sign@#⌈Abs@#⌉&

Try it online!

— attinat
fonte

1

Factor, 57 bytes

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

Try it online!

— Galen Ivanov
fonte

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é
fonte

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
fonte

1

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

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

Try it online!

— Xcali
fonte

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
fonte

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
fonte

0

Java (OpenJDK 8), 43 bytes

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

Try it online!

— X1M4L
fonte

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
fonte

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
fonte

0

Scala, 16 bytes

_.setScale(0,UP)

Try it online!

Scala, 22 bytes

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

Try it online!

— Soapy
fonte

Arrotondare da zero

Arrotondare da zero

Casi test

Excel, 13 byte

Alternativa

R, 32 byte

Gelatina , 4 byte

Come?

Python 3 , 23 byte

Gelatina , 5 4 byte

Gelatina , 6 5 byte

Come funziona questo

Java (JDK) , 18 byte

spiegazioni

Vim, 36 byte / sequenze di tasti

J , 6 byte

C # (compilatore Visual C #) , 41 byte 27 byte 24 byte

Incantesimi runici , 18 16 byte

Stax , 6 byte

Procedura:

C, 94 43 39 byte

Retina 0.8.2 , 38 byte

05AB1E , 6 byte

JavaScript (ES6), 20 byte

Commentate

Perl 6 , 18 byte

Spiegazione

MathGolf , 5 byte

Spiegazione

PHP , 30 byte

PHP , 32 byte

PHP , 34 byte

Brachylog , 7 byte

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