Arredondar para zero

24

Arredondar para zero

Inspirado pelo círculo em direção a zero .

Dada uma entrada numérica por qualquer método razoável, arredonde o número "longe de zero" - números positivos são arredondados para cima e números negativos são arredondados para baixo.

Se você pretende usar a entrada como uma string (via STDIN, por exemplo), deve poder manipular números com ou sem o ponto decimal. Se você o considera um número, ele deve pelo menos ser capaz de lidar com precisão de ponto flutuante (precisão dupla não é necessária) ou números racionais.

Você pode emitir um número de ponto flutuante com o ponto decimal (por exemplo, 42.0), se desejar. (Ou mesmo alguns casos de teste produzem ponto flutuante e algum número inteiro, se a resposta for mais curta.)

Não são permitidas brechas padrão, etc.

Casos de teste

-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

Sandbox Link

code-golf  number 
— Value Ink
fonte
se estivermos pegando números em um contexto de string, como STDIN, precisamos dar suporte ao .0que os casos de teste parecem sugerir?
— Jo King
@JoKing yes-- Vou atualizar a pergunta para esclarecer. Este foi realmente o caso original, mas depois as pessoas na caixa de areia sugeriu acrescentar casos de teste não-decimais para uh, aqui estamos nós com ambos, desculpe
— Valor Ink
É bom ser inspirador :)
— connectyourcharger
É engraçado que todos os idiomas que se saíram tão bem no desafio anterior ao receber entradas e saídas inteiras não funcionem tão bem, pois não sabem a diferença entre -0.1e0.1
— Jo King

Respostas:

15

Excel, 13 bytes

=ROUNDUP(A1,)

Alternativo

=EVEN(A1*2)/2
— Nwellnhof
fonte
4
EVEN, que função estranha ..
— tsh
13
@tsh Acho que você quer dizer "função ímpar".
— negativo sete de
2
@negativeseven O nome do usuário faz check-out. :-P
— Veky
8

Gelatina , 4 bytes

ĊṠ¡Ḟ

Um link monádico que aceita um número que gera um número inteiro.

Experimente online! Ou veja uma suíte de testes .

Quão?

ĊṠ¡Ḟ - 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
Então, como exatamente ¡funciona para números negativos? Eu não acho que está documentado
— caird coinheringaahing 03/09
11
Não está documentado no wiki de Jelly, mas ¡a natureza repetitiva é implementada com um for index in range(repetitions)loop no código. range([stop=]-1)está vazio, já que o startpadrão é 0e o steppadrão é 1"Para uma etapa positiva, o conteúdo de um intervalo ré determinado pela fórmula r[i] = start + step*ionde i >= 0e r[i] < stop". docs
— Jonathan Allan
¡O comportamento de baseia-se no de Python rangee range(-1).__iter__().__next__()lança imediatamente StopIteration.
— String não relacionada
6

Python 3 , 23 bytes

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

Experimente online!

-1 byte graças ao xnor

— Jitse
fonte
11
Você pode fazer (1|-(i>0))para salvar um byte (1,-1)[i>0].
— xnor 4/09
@xnor Bom achado, obrigado!
— Jitse 4/09
Bem feito. Eu o tinha em 62 bytes ಥ_ಥ:g=lambda r:0if r==0 else(int(r)+r/abs(r)if r/int(r)!=1 else r)
— user14492 04/09
O que é o '|' antes de o '-'?
— William
11
@jaaq Eu também gosto muito dessa solução! Minha abordagem inicial também foi de 24 bytes.
— Jitse 6/09
5

Geléia , 5 4 bytes

AĊ×Ṡ

Experimente online!

Esta porta recursiva fornece a resposta Stax do Jelly no Jelly, portanto verifique essa resposta para obter uma explicação.

-1 byte graças a Nick Kennedy

Gelatina , 6 5 bytes

ĊḞ>?0

Experimente online!

-1 byte graças a Jonathan Allan

Como este funciona

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

   ?  - If:
  > 0 -   x > 0
      - Then:
Ċ     -   ceil(x)
      - Else:
 Ḟ    -   floor(x)
— caird coinheringaahing
fonte
ĊḞ>?0funcionaria como o seu 6.
— Jonathan Allan em
11
AĊ×Ṡé 4 e funcionalmente idêntico à sua primeira resposta.
— Nick Kennedy em
@NickKennedy e Jonathan, obrigado pelas sugestões, eles foram editados em
— caird coinheringaahing
5

Java (JDK) , 18 bytes

d->d.setScale(0,0)

Experimente online!

Explicações

Usa a BigDecimalcomo entrada e saída. BigDecimalpossui um método setScaleque define a escala do número. O primeiro parâmetro é o número de dígitos após o separador de pontos, o segundo é o modo de arredondamento. ROUND_UPé o arredondamento "longe de zero" e tem um valor de 0modo que eu codifique esse valor.

— Olivier Grégoire
fonte
5

Vim, 36 bytes / pressionamentos de tecla

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

Experimente online! ou Verifique todos os casos de teste!

Explicação:

: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
Usando em $F-a <esc>vez da primeira linha e uma macro com /como condicional no lugar de :ge :normfornece 29 bytes tio.run/##HczBCoJAFEZhWva/QpuLCNbizoxalBXRInqJMpjGCYVwmkx7/…
— Kritixi Lithos
4

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

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

Experimente online!

Primeiro post aqui, me diverti com ele, espero que você goste. Meio que senti que o lugar do C # está vazio aqui

-14 tnx em @ dados expirados
-3 tnx em @ night2

— hessam hedieh
fonte
11
Bem-vindo ao site, e boa primeira resposta! Espero que você goste do Code Golf!
— caird coinheringaahing 04/09
27 bytes ... Provavelmente ainda faltam alguns para salvar
— Data de
@ Expirado, sim, legal, esse tipo de código era tão estranho à primeira vista que parece que eu esqueci toda a coisa da biblioteca, lembre-se de publicá-la como resposta
— hessam hedieh
11
@ Night2, tnx para o comentário, eu não digitei a resposta inteira, usei a Code golf submissionfuncionalidade, apenas adicionei um pouco de minhas próprias palavras ao final, mas para editar, apenas alterei a linha do código e você está aí, esqueci de atualize o link, o que nos leva de volta à primeira etapa, para modificar apenas uma vez, meio SOLID aqui, enfim, tnx para a dica também
— hessam hedieh
11
Você editou o link do TIO para a versão de 24 bytes, mas a própria linha de código ainda é a versão de 27 bytes.
— Value Ink
4

Encantos Rúnicos , 18 16 bytes

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

Experimente online!

"Adiciona" (longe de zero) 0,999999 e pisa o resultado. µé a coisa mais próxima de um infinitesimal nos operadores da linguagem. Com um Trunc(x)comando funcionando corretamente , a resposta agora suporta 0como entrada.

— Draco18s
fonte
11
@JoKing Oof. Boa pegada. Ele está fazendo um divide by inputpara obter o "sinal" do valor da entrada, que, é claro, divide por 0 quando a entrada é 0. Não há nenhuma maneira (boa) de contornar isso no momento. Primeiro precisará desse commit . Vou cutucar Dennis (benefício colateral, a resposta ficará mais curta).
— Draco18s
11
A resposta @JoKing agora funciona 0corretamente.
— Draco18s 7/09
2

Retina 0.8.2 , 38 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

\.0+
.

Exclua zeros após o ponto decimal, para garantir que o número não seja um número inteiro; as próximas duas correspondências falharão se não houver dígitos após o ponto decimal.

\b9+\..
0$&

Se a parte inteira for toda 9s, prefixe a 0para permitir que o incremento seja excedido.

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

Incremente a parte inteira do número.

\..*

Exclua a parte fracionária do número.

— Neil
fonte
2

JavaScript (ES6), 20 bytes

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

Experimente online!

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
— Arnauld
fonte
Eu estava escrevendo uma resposta para minha resposta de 16 bytes ( n=>(~~n-n%1)%1+n) até descobrir que meu código não funcionava para números entre -1 e 1. Você pode descobrir como fazer isso funcionar com os últimos 3 bytes. esquerda!
— Gust van de Wal
2

Perl 6 , 18 bytes

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

Experimente online!

Explicação

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

MathGolf , 5 bytes

‼σ±ü*

Experimente online!

Explicação

É bom encontrar uso para o ‼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
— maxb
fonte
2

PHP , 30 bytes

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

Experimente online!

Se o número não for inteiro, com base no sinal -1 (para decimais negativos) ou 1 (para decimais positivos) será adicionado e, em seguida, parte inteira do novo número será impressa.

PHP , 32 bytes

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

Experimente online!

Basicamente, saídas floorde entrada, se for menor que 0, caso contrário ceil.

PHP , 34 bytes

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

Experimente online!

— Night2
fonte
1

APL (Dyalog Unicode) , 15 bytes

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

Experimente online!

Dfn simples. Usos⎕IO←0 .

Quão:

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

/^-?[^.]*(\.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/\..*$//
— Raio
fonte
1

JavaScript (node.js), 30 23 21 bytes

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

Inspirado pela resposta em C #.

Graças a @Value Ink e @Gust van de Wal por -7 bytes!

Mais uma vez obrigado, @Gust van de Wal por mais -2 bytes!

— Sagitário
fonte
Por que usar +=quando +fará o truque neste caso? -1 byte
— Value Ink
Em vez de parseInt(), eu apenas usaria ~~no início ou outro operador bit a bit como |0ou ^0no final para salvar outro pedaço de bytes
— Gust van de Wal
@ValueInk uau, eu não tenho idéia do porquê eu escrevi +=, thx por apontá-lo
— Sagitário
Você ainda pode soltar os parênteses externos
— Gust van de Wal
@GustvandeWal oh, eu não sabia disso! obrigado
— Sagitário
0

Perl 6 , 19 bytes

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

Experimente online!

Não é a solução mais curta, mas estou trabalhando nisso. Basicamente, isso trunca o número e, em seguida, adiciona um valor a zero se o número não era inteiro para começar.

— Brincadeira
fonte
0

Vermelho , 46 bytes

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

Experimente online!

A versão um pouco mais legível tem 2 bytes mais (esses nomes de funções longos!): 

func[n][to 1(sign? n)* round/ceiling absolute n]
— Galen Ivanov
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.