15
\$\begingroup\$

This is a simple task. Given a positive or negative real number, round it to the next whole integer closer to zero.

The challenge

  • Take input through any reasonable form (stdin, function, etc.) of one positive or negative real number.

  • Round this number "towards zero" - this means if it is positive you will round down, and if it is negative you will round up.

  • Return the number or output it to the console.

Test cases

 1.1   =>  1
-1.1   => -1
 500.4 =>  500
-283.5 => -283
 50    =>  50
-50    => -50

Rules

Have fun! more Jimmy challenges coming soon

| improve this question | | | | |
\$\endgroup\$
  • 3
    \$\begingroup\$ May i output 3.00 for 3.14? \$\endgroup\$ – tsh Aug 23 '19 at 5:33
  • 1
    \$\begingroup\$ @A_ If error messages are in stderr. And your output are in stdout. It is allowed by default. \$\endgroup\$ – tsh Aug 23 '19 at 6:59
  • 1
    \$\begingroup\$ Also 0.01 and -0.01 should yield 0... \$\endgroup\$ – roblogic Aug 23 '19 at 10:33
  • 2
    \$\begingroup\$ Hmm, this seems unreasonably trivial for a code golf. Most langs will have a builtin for this, no? It looks like we are to assume all input and output are strings? \$\endgroup\$ – Octopus Aug 23 '19 at 19:13
  • 2
    \$\begingroup\$ 3.00 certainly is an integer. More precisely, in standard mathematical notation as well as in many programming languages, the notation "3.00" denotes the number 3, which is an integer; but in many programming languages, it indicates that the number is to be stored in a floating-point format. (But it's an integer regardless of the format it's stored in.) \$\endgroup\$ – Tanner Swett Aug 23 '19 at 20:06

59 Answers 59

13
\$\begingroup\$

Jelly, 1 byte

r

A full program (as a monadic Link it returns a list of length one).

Try it online!

How?

r - Main Link: number, X           e.g. -7.999
r - inclusive range between left (X) and right (X) (implicit cast to integer of inputs)
  -  = [int(X):int(X)] = [int(X)]       [-7]
  - implicit (smashing) print            -7
| improve this answer | | | | |
\$\endgroup\$
42
\$\begingroup\$

Python 3, 3 bytes

int

Try it online!

Truncates the digits after the decimal point.

NOTE: This is a trivial answer. Please take a look at the other answers before upvoting

| improve this answer | | | | |
\$\endgroup\$
  • 19
    \$\begingroup\$ This demonstrates that Python 3 is more popular than Python 2. \$\endgroup\$ – user85052 Aug 23 '19 at 5:09
  • 1
    \$\begingroup\$ Err... Why the upvotes? This is a pretty trivial answer... \$\endgroup\$ – MilkyWay90 Aug 23 '19 at 16:34
  • \$\begingroup\$ I think it's your excellent explanation of the code. :) \$\endgroup\$ – Chas Brown Aug 23 '19 at 22:37
  • 3
    \$\begingroup\$ @ChasBrown I don't think so... the explanation is not even a standard caliber explanation. \$\endgroup\$ – MilkyWay90 Aug 23 '19 at 23:08
  • \$\begingroup\$ I guess @Chas is pointing out that the explanation is infinitely more complete than his own. \$\endgroup\$ – prl Aug 26 '19 at 0:46
22
\$\begingroup\$

Python 2, 3 bytes

int

Try it online!

| improve this answer | | | | |
\$\endgroup\$
  • 2
    \$\begingroup\$ Sorry, but I ninja'ed you (codegolf.stackexchange.com/a/190673/83048) \$\endgroup\$ – MilkyWay90 Aug 22 '19 at 23:36
  • 2
    \$\begingroup\$ Arg! But you're using Python 3... :) \$\endgroup\$ – Chas Brown Aug 22 '19 at 23:37
  • \$\begingroup\$ True, people should know it works in Python 2 too \$\endgroup\$ – MilkyWay90 Aug 22 '19 at 23:38
  • \$\begingroup\$ Unfortunately you got bamboozled by about a minute :( \$\endgroup\$ – connectyourcharger Aug 22 '19 at 23:40
  • 3
    \$\begingroup\$ I wuz robbed! :) \$\endgroup\$ – Chas Brown Aug 22 '19 at 23:42
12
\$\begingroup\$

Perl 5 -p056l15, 2 bytes

<>

Try it online!

How does that work?

-056   # (CLI) Make "." the input record separator
-l15   # (CLI) Make "\n" the output record separator
       # (otherwise it would use the input separator)
-p     # (CLI) Implicitly read $_ from STDIN
<>     # Read the second input field and do nothing with it
-p     # (CLI) Output $_ to STDOUT

Or if you prefer a more traditional answer:

Perl 5, 6 bytes

$_=int

Try it online!

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ l15 isn't \n, it's \r. \n would be l12. It looks the same in TIO, though. \$\endgroup\$ – Grimmy Aug 23 '19 at 7:56
  • \$\begingroup\$ for the second option, there's also -Minteger -p $_/=1 \$\endgroup\$ – Nahuel Fouilleul Aug 23 '19 at 10:32
  • 4
    \$\begingroup\$ The first solution is actually 8 bytes because you need to include the flags in your byte count \$\endgroup\$ – John Dvorak Aug 23 '19 at 10:59
  • 2
    \$\begingroup\$ @JohnDvorak actually per the meta post codegolf.meta.stackexchange.com/questions/14337/…, flags don’t add bytes but count as a different version of the language. \$\endgroup\$ – Nick Kennedy Aug 23 '19 at 13:14
  • \$\begingroup\$ @NahuelFouilleul I thought about that one, too, but it didn't matter since I got to 2 bytes the other way. \$\endgroup\$ – Xcali Aug 23 '19 at 22:07
6
\$\begingroup\$

Labyrinth & Hexagony, 3 bytes

Thanks to FryAmTheEggman for pointing out I'd written some Hexagony!

?!@

Try it online! & Try it online!

How?

Labyrinth and Hexagony will both tell you as early as possible!...

? - read and discard from STDIN until a digit, a - or a + is found. Then read as many characters as possible to form a valid (signed) decimal integer and push its value
! - pop a value and write its decimal representation to STDOUT
@ - exit the labyrinth
| improve this answer | | | | |
\$\endgroup\$
  • 3
    \$\begingroup\$ This may be true of some of Martin's other languages, but the exact same program works in Hexagony. \$\endgroup\$ – FryAmTheEggman Aug 23 '19 at 1:20
  • 3
    \$\begingroup\$ Heh, I've always wanted to make an answer in Hexagony. Doing it without trying was the last thing I thought could happen! \$\endgroup\$ – Jonathan Allan Aug 23 '19 at 1:23
  • \$\begingroup\$ IO@ in Backhand works the same way, and &.@ in Befunge. Probably a lot of languages with integer input, and only integer handling will be the same \$\endgroup\$ – Jo King Aug 23 '19 at 1:27
  • \$\begingroup\$ @JoKing So we are waiting for someone finding out a language with integer i/o and also reading all number from stdin to stack / list and then print them to stdout by default. I believe there could be one, and it would be an answer in zero bytes. \$\endgroup\$ – tsh Aug 23 '19 at 5:46
  • \$\begingroup\$ @tsh most probably! \$\endgroup\$ – Jonathan Allan Aug 23 '19 at 6:50
6
\$\begingroup\$

brainfuck, 26 bytes

,[.+++++[->+++++<]>+[,>]<]

Try it online!

Outputs with a trailing . if the number was a decimal

There's not much specual golfing wise, except that instead of subtracting 46 to check if a character is a ., I add 5 and multiply by 5 to get 255, then add one more to roll over to zero. Subtracting 3, multiplying by 6 and subtracting 2 is the same bytecount

| improve this answer | | | | |
\$\endgroup\$
6
\$\begingroup\$

C (tcc), 39 21 10 bytes

I was actually quite surprised nobody thought of using C.

f(float i){}

This is not an identity function as it seems to be. The implicit int type of the f function trunctuates the floating-point.

TIO

Less likely to trick people but has a shorter byte length:

f(int i){}

TIO

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ Do not work with float as this uses different register for input of floating point values. \$\endgroup\$ – Hauleth Sep 4 '19 at 17:04
4
\$\begingroup\$

J, 6 bytes

**<.@|

Try it online!

Sign * times * the round down <. of the absolute value @|

| improve this answer | | | | |
\$\endgroup\$
3
\$\begingroup\$

Perl 6, 4 bytes

*+|0

Anonymous function.

Try it online!

| improve this answer | | | | |
\$\endgroup\$
3
\$\begingroup\$

Java (OpenJDK 8), 15 bytes 9 bytes

s->(int)s

Try it online!

thanks to @kevin-cruijssen

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ 9 bytes by using an interface lambda so we can use primitives and a simple cast to (int). And here a fun 15 bytes alternative using a method reference. :) \$\endgroup\$ – Kevin Cruijssen Aug 23 '19 at 10:03
  • 1
    \$\begingroup\$ @KevinCruijssen thank you for pointing out the 9 bytes answer! And the 15bytes alternative solutions is brilliant! Also big fan of your answers! I got inspired to join the community also for your contributions :D \$\endgroup\$ – Margon Aug 23 '19 at 10:10
  • \$\begingroup\$ Glad I could help, and fun to hear I'm an inspiration. :D Welcome! Oh, and if you haven't seen them yet, tips for golfing in Java and tips for golfing in <all languages> might both be interested to read through. Enjoy your stay! :) \$\endgroup\$ – Kevin Cruijssen Aug 23 '19 at 10:13
  • \$\begingroup\$ Thank you! :) I already read all the tips and lurked a lot actually before posting! Hope I can answer more in the future! \$\endgroup\$ – Margon Aug 23 '19 at 10:27
3
\$\begingroup\$

Excel, 10 bytes

=TRUNC(A1)

TRUNC truncates a number to an integer by removing the fractional part of the number.

| improve this answer | | | | |
\$\endgroup\$
3
\$\begingroup\$

R, 13 5 bytes

Thanks Robin Ryder

trunc

Try it online!

| improve this answer | | | | |
\$\endgroup\$
  • 2
    \$\begingroup\$ There is consensus that it is acceptable to answer with either a function or a full program. Here, the function form is only 5 bytes. \$\endgroup\$ – Robin Ryder Aug 24 '19 at 6:00
2
\$\begingroup\$

Retina 0.8.2, 5 bytes

\..*

Try it online! Link includes test cases.

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Ruby, 11 bytes

proc &:to_i

I picked this one because it distinguishes itself from the lambdas that us Ruby golfers typically use (thankfully, it had the same bytecount as the "traditional" solution):

->n{n.to_i}

Try it online!

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

ReRegex, 12 bytes

\..+//#input

Try it online!

ReRegex is a programming language which matches and replaces over and over until there are no matches.

MATCH
    \.                                      The literal period/full stop char
    .+                                      Followed by one or more characters
REPLACE
    (nothing)                               Equivalent to removing the input
STRING TO REPEATEDLY MATCH/REPLACE UNTIL THERE ARE NO MATCHES
    #input                                  The input
| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

JavaScript, 6 bytes

x=>x^0

Try it online!


JavaScript, 8 bytes

Using built in is 2 bytes longer...

parseInt

Try it online!

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ Also x=>~~x? Still 6 bytes though. \$\endgroup\$ – mherzig Aug 23 '19 at 23:08
2
\$\begingroup\$

K (oK), 3 bytes

`i$

Try it online!

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Intel 8087 FPU machine code, 14 bytes

D9 2E 010C      FLDCW CW_RNDZ   ; modified CW register for round towards zero
D9 06 010E      FLD  A          ; load single precision value A into ST(0)
DF 16 0112      FIST B          ; store integer value of ST(0) into B

CW_RNDZ   DW    0F7FH           ; control word to round down

Input is single precision value in a memory location A (a DD), output is integer value at memory location B (a DW).

The 8087 must first be put into round towards zero mode by setting the control word (0F7FH). Then load the floating point value and store back to an integer.

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Red, 4 bytes

to 1

Try it online!

Just converts the float to an integer (conversion by prototype)

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Zsh, 10 bytes

<<<$[0^$1]

xor with 0. I came across this during another challenge recently. Try it online!

Does not work in Bash or POSIX sh (dash).

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

V (vim), 4 bytes

Á.#D

Try it online!

Thanks @DJMcMayhem, 1 byte saved.

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Keg, 19 17 13 bytes

This outputs some trailing unprintable characters. Also, this exits with an error. (Now we need reversed input!)

?'(:\.>')"([,
| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Whitespace (with vii5ard compiler), 18 17 bytes

[S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][T  N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online. You'll have to copy-paste the code yourself (note that SE converts the tabs to a bunch of spaces!) in order to run the code at the online Whitespace-compiler vii5ard. When clicking run, it will ask for an input (i.e. -283.5), and after clicking enter it will continue and output -283.

Explanation in pseudo-code:

Integer i = STDIN as integer
Print i as integer

Whitespace can only use I/O as integers or single characters, so in this case, the input is read as integer and all other subsequent characters are ignored. I.e. -283.5 or -283abc5 would both be input (and thus output) as -283.

Unfortunately this above doesn't work on TIO for two reasons (all Whitespace compilers are slightly different..):

  1. It will give a no parse error when we try to read an input as integer, which isn't an a valid integer. So, instead we'll read one character at a time, and stop (with an error) as soon as we've encountered the . or there is no more input (i.e. 50/-50).
  2. In the vii5ard compiler it's also possible to push 0 with just SSN, whereas on TIO it requires an additional S or T: SSSN/SSTN. The first S is Enable Stack Manipulation; the second S is Push what follows as integer; the third S/T is positive/negative respectively; and any S/T after that (followed by an N) is the number we want to push in binary, where S=0 and T=1. For integer 0 this binary part doesn't matter, since it's 0 by default. But on TIO we'd still have to specify the positive/negative, and with most other Whitespace compilers like vii5ard not.

Whitespace (with TIO compiler), 48 bytes

[N
S S N
_Create_Label_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve_input][S N
S _Duplicate_input][S S S T S T T   T   S N
_Push_46_.][T   S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_EXIT][T N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Explanation in pseudo-code:

Start LOOP:
  Character c = STDIN as character
  If(c == '.'):
    Exit program
  Print c as character
  Go to the next iteration of LOOP
| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Pip, 5 bytes

a//:1

Try it online!

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Haskell, 8 bytes

truncate

Try it online!

A built-in that truncates the non-integer part of the number.

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

C# (Visual C# Interactive Compiler), 9 bytes

n=>(int)n

Try it online!

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Scala, 7 bytes

_.toInt

Try it online!

| improve this answer | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ 8 byte solution x=>x-x%1. Double=>Double in this case. \$\endgroup\$ – Dr Y Wit Aug 23 '19 at 11:04
1
\$\begingroup\$

05AB1E, 1 byte

ï

In the legacy version (which is written in Python), the cast to integer builtin works as expected to truncate the decimal values.

Try it online.

In the new version of 05AB1E (written in Elixir) it only works on strings (even though integers/decimals/strings should all be interchangeable, unless sorting lexicographical vs numeric for example). Guess I can report a bug to @Adnan..

Try it online to compare integer/decimal input (giving incorrect result) vs string inputs (giving correct results).

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Aheui (esotope), 9 bytes

방망희

Try it online!

Basic idea from that of triangular answer (or any other languages takes numeric input as integer).

Fun fact. 방망희(pronounced bang-mang-heui(a of ark)) sounds almost same as 방망이(pronounced bang-mang-i(a of ark, i sounds like E), which means bat.

How does it works?

takes number as integer.

prints value as number.

terminates program.

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

PowerShell, 19 bytes

$args-replace'\..*'

Try it online!

PowerShell by default does bankers' rounding, which is pretty much the opposite of how many other languages do rounding. So, traditionally we'd use [Math]::Truncate() to strip the decimal point and any decimal part and achieve the "to zero" rounding we're interested in here. However, that's a bit long, so using this tip, we can round-toward-zero by implicitly casting the input to a string, performing a regex -replace to get rid of the period and anything after it, and leaving the output on the pipeline for implicit printing.

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ I don't think this would give the desired result for negative numbers. \$\endgroup\$ – Octopus Aug 23 '19 at 19:16
  • \$\begingroup\$ @Octopus Sure it does? It just trims off the decimal portion, which moves the number toward zero whether from positive or negative floats. \$\endgroup\$ – AdmBorkBork Aug 23 '19 at 19:26
  • \$\begingroup\$ Right, duh. Lol. \$\endgroup\$ – Octopus Aug 23 '19 at 19:28

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.