text:
Round towards zero
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.9   =>  1
-1.1   => -1
 500.4 =>  500
-283.5 => -283
 50    =>  50
-50    => -50

Rules

This is code-golf, so least score in bytes wins.

Be mindful of the standard loopholes.

Have fun!
more Jimmy challenges coming soon

Can we leave a trailing . on the output?

Similarly, may we assume the input always contains a .? Or that the input won't start with a .?

@Xcali Yes you may.

@JoKing The input may not always contain a . (as in 50) and the input should not start with a ..

May i output 3.00 for 3.14?

Can we leave trailing unprintables on the output and leave with an error?

@A_ If error messages are in stderr. And your output are in stdout. It is allowed by default.

Can you add test cases for 9.99 and -9.99 ? Should round to 9 and -9 right?

Also 0.01 and -0.01 should yield 0...

more Jimmy challenges coming soon +1

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?

@tsh 3.00 isn't an integer.

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.)

does it need to handle the weird floating point edge cases?

Rounding towards zero, that is, discarding the fractional part, is called truncation and is a standard operation in almost all languages. Typically, doing this kind of rounding is more "basic" than doing a ceil or a floor.

Does this need to work with very large numbers? If so, somewhat less trivial.

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

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

This demonstrates that Python 3 is more popular than Python 2.

Err... Why the upvotes? This is a pretty trivial answer...

I think it's your excellent explanation of the code. :)

@ChasBrown I don't think so... the explanation is not even a standard caliber explanation.

I guess @Chas is pointing out that the explanation is infinitely more complete than his own.

@prl Ah, I see now.

@A_ Probably not.

python 4!!!!!!!!

this doesn't actually do anything

Python 2, 3 bytes
int

Try it online!

Sorry, but I ninja'ed you (https://codegolf.stackexchange.com/a/190673/83048)

Arg! But you're using Python 3... :)

True, people should know it works in Python 2 too

Unfortunately you got bamboozled by about a minute :(

I wuz robbed! :)

@ChasBrown You were robbed of your python (snake), which was 2 years old, by a ninja who had a 3 year old python.

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!

l15 isn't \n, it's \r. \n would be l12. It looks the same in TIO, though.

for the second option, there's also -Minteger -p $_/=1

The first solution is actually 8 bytes because you need to include the flags in your byte count

@JohnDvorak actually per the meta post https://codegolf.meta.stackexchange.com/questions/14337/command-line-flags-on-front-ends, flags don’t add bytes but count as a different version of the language.

@NahuelFouilleul  I thought about that one, too, but it didn't matter since I got to 2 bytes the other way.

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

This may be true of some of Martin's other languages, but the exact same program works in Hexagony.

Heh, I've always wanted to make an answer in Hexagony. Doing it without trying was the last thing I thought could happen!

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

@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.

@tsh most probably!

Same code works for Trilangle, though the online interpreter won’t currently demonstrate this: https://github.com/bbrk24/Trilangle/issues/4

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

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

Do not work with float as this uses different register for input of floating point values.

Perl 6, 4 bytes
*+|0

Anonymous function.
Try it online!

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!

J, 6 bytes
**<.@|

Try it online!
Sign * times * the round down <. of the absolute value @|

R, 13 5 bytes
Thanks Robin Ryder

trunc

Try it online!

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.

The same in Julia :).

Retina 0.8.2, 5 bytes
\..*

Try it online! Link includes test cases.

JavaScript, 6 bytes
x=>x^0

Try it online!

JavaScript, 8 bytes
Using built in is 2 bytes longer...
parseInt

Try it online!

Also x=>~~x? Still 6 bytes though.

Java (OpenJDK 8), 15 bytes 9 bytes
s->(int)s

Try it online!
thanks to @kevin-cruijssen

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. :)

@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

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  might both be interested to read through. Enjoy your stay! :)

Thank you! :) I already read all the tips and lurked a lot actually before posting! Hope I can answer more in the future!

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..):

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).
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

K (oK), 3 bytes
`i$

Try it online!

Excel, 10 bytes
=TRUNC(A1)

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

Husk, 3 bytes
→…0

Try it online!
Takes a range … from 0 toward the input, then gets its last element →.
For a positive input this goes like 3.3; [0,1,2,3]; 3.
For a negative input this goes like -3.3; [0,-1,-2,-3]; -3.

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

V (vim), 4 bytes
Á.#D

Try it online!
Thanks @DJMcMayhem, 1 byte saved.

Intel 8087 FPU machine code, 9 bytes
00000000: d92e 0701 d9fc c37f 0f                 .........

Listing:
D9 2E 0107      FLDCW   CW_RNDDN    ; set FPU CW for truncate (floor) rounding mode
D9 FC           FRNDINT             ; ST = ROUND_TO_ZERO( ST )
C3              RET                 ; return to caller
    CW_RNDDN    DW  0F7FH           ; control word to round down

Callable function, input is in ST(0), output to ST(0).
The 8087 must first be put into round towards zero mode by setting the control word (0F7FH). Rounding towards zero would then take place.

Keg, 19 17 13 bytes
This outputs some trailing unprintable characters. Also, this exits with an error. (Now we need reversed input!)
?'(:\.>')"([,

Exiting with an error is allowed by default

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.

Red, 4 bytes
to 1

Try it online!
Just converts the float to an integer (conversion by prototype)

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).

GNU sed, 8 bytes
s:\..*::

Try it online!
GNU sed has no concept of numbers. The code removes all text after and including the dot.

slight issue, -0.5 returns -0.

@roblogic There are other answers that do this kind of truncation. Mathematically, the output is correct. I would have to add s:-0:0: to handle this slight issue, thus doubling the size of the code.

><>, 6 bytes
:1%-n;

Try it online!
Assuming the input is pushed onto the stack. The language specification allowed doing so:

While parsing numbers is not very hard, it makes for slow and possibly glitchy programs. Most programs requiring number input reads it from the stack at program start. This is done with an interpreter that supports pre-populating the stack with values.

Explanation:
:      Duplicated the input
 1%    Take the fractional part
   -   The original input minus the fractional part, results in the integer part
    n  Output as a number
     ; Terminates

If error is allowed:
><>, 5 bytes
:1%-n

Try it online!
The n command at the end pops and outputs the top of the stack. Then, the IP returns to the first character(because the code is laid out in a torus), and reached a "duplicate" command when the stack is empty. Thus, it errors and terminates.

Terminating with an error is allowed by default.

@MilkyWay90 Thanks for mentioning that.

Husk, 4 bytes
←x'.

Try it online! Splits the string on '.' and takes the first segment.

Pip, 5 bytes
a//:1

Try it online!

Triangular, 3 bytes
$.%

Try it online!
Triangular takes numeric input as an integer; any decimal values are truncated.
If it's acceptable to just leave the input on the stack without printing it, then this solution can instead be:

Triangular, 1 byte
$

Try it online!

Haskell, 8 bytes
truncate

Try it online!
A built-in that truncates the non-integer part of the number.

C# (Visual C# Interactive Compiler), 9 bytes
n=>(int)n

Try it online!

Japt -P, 1 byte
ì

Try it
Alternative 2-byte solution that doesn't use flags:
|0

Try it
The | operator to coerces the input value to an integer.
There may be a 1-byte solution without flags, but I have not come up with it yet.

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).

ï works just fine on non-legacy 05AB1E. It's array input that works in a weird way.

@Grimy Ah, it's string vs integer/decimal. Strings work correct, but integers/decimals not.

Scala, 7 bytes
_.toInt

Try it online!

8 byte solution x=>x-x%1. Double=>Double in this case.

ed(1), 40 bytes
try it out on the intertubes
g/-0.*/s//0/
,s/\([0-9\-]*\).*/\1/gp
w
.

Someone on twitter was rather impolite about using ed:

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.

I don't think this would give the desired result for negative numbers.

@Octopus Sure it does? It just trims off the decimal portion, which moves the number toward zero whether from positive or negative floats.

Right, duh. Lol.

Brachylog, 6 bytes
↔a₁↔ịℤ

Try it online!
Takes input as a string.
↔a₁↔      The longest prefix of the input
    ị     which converted to a number
     ℤ    is an integer, is the output (as an integer).

33, 2 bytes
Oo

Try it online!
Simple solution. 33 doesn't support floating-point numbers, so getting input will only retreive the integer part of it, truncating the decimal places.

Stax, 5 bytes
i'./h

Run and debug it
Splits as a string on "." and returns the first part.

PHP, 6 bytes
Built-in function:
intval

Try it online!

PHP, 11 bytes
Full program:
<?=0^$argn;

Try it online!

Julia (1.2), 5 bytes
trunc

Full program, 24 bytes
print(trunc(readline()))

APL, 5 bytes
××⌊∘|

Explanation: This is a fork; when evaluated at a number r, it computes:
(×r) × (⌊∘|r)

i.e. sign(r) x floor(abs(r))

Try it online!

MAWP, 41 bytes
%|0~59WA{59WM}<59WM;>[85W6MA?.{85W6MM;}]

-3 bytes after rearranging the beginning conditionals.
-1 byte from Dion after replacing <> with ?
Checks for - in the first character, then prints number using ASCII values till a . is reached.
Try it!

Use ?. instead of <.> for saving a byte

Keg, 7 bytes
{:\.≠|,

Try it online!
It's Just A Port of the MAWP program because maths is overrated. ;p

Whispers v3, 32 30 bytes
> Input
>> ⌈1⌋
>> Output 2

Try it online!
-2 bytes from Michael Chatiskatzi.

30 bytes if you use ⌈⌋ to convert the number into an integer

@MichaelChatiskatzi wow, thanks!

Vyxal, 1 byte
I

Try it Online!
Casts input to int, stripping any decimals.

Risky, 12 bytes
+/+2}/??+_0{11111111111

Try it online!
Takes a string, since Risky doesn't support real numbers.

Wolfram Language (Mathematica), 11 bytes
IntegerPart

Try it online!

Ohm v2, 1 byte
ì

Try it online!

MathGolf, 1 byte
i

Try it online!
Casts the input to integer, using Python's int. As easy as it gets.

IBM/Lotus Notes Formula, 11 bytes
@Integer(i)

Takes input from a form field i. Only posted because of the fun feature that given a list the formula will be applied to all members of the list without the need of a @For loop and also because I haven't posted a Notes Formula answer for a while.
There is no online interpreter for Formula language so a screenshot showing output for all given test cases is the best I can do.

x86-64 Machine Code (Windows), 5 bytes
F3 0F 2C C0          cvttss2si   eax,xmm0
C3                   ret

cvttss2si - Convert with truncation scalar single to integer.

Pyth, 1 byte
s

Try it online!
Equivalent of Python's int(i) with implicit input and output.

T-SQL, 16 bytes
Shorter than cast(@ as int)
DECLARE @ DECIMAL(10,5)=-11.7
PRINT str(@-@%1)

Can save 5 bytes by removing str() if output like -11.00000 is allowed

Befunge-93, 3 bytes
&.@

Try it online!

Rust, 10 bytes
f64::trunc

Try it online!
Rustdoc of f64::trunc.

Pascal (FPC), 44 bytes
function b(a:Real):Real;begin b:=Int(a);end;

Try it online!

Oracle SQL, 23 bytes
select x-mod(x,1)from t

Try it online!

C (clang), 15 bytes
f(i){return i;}

Try it online!
For some reason, this doesn't work with GCC. Also, in real life, because C allows implicit conversion between floats and ints (which is being exploited in this function), you sometimes wouldn't have to write any code at all to round something towards zero. And that fact is probably used in a lot of C answers on Code Golf.

Runic Enchantments, 13 5 bytes
i'.A@

Try it online!
Now that the A command supports Trunc(x), the answer now works on 0 as input and is shorter, as it no longer needs to jump through hoops to determine the input's sign.

Emacs Lisp, 9 bytes
'truncate
Try it online!

Kotlin, 9 bytes
x.toInt()

There’s also truncate() function which is longer in bytes.

I don't know Kotlin, but this doesn't look like a full program or function. You could probably convert it to a lambda expression fairly easily. Welcome to CG&CC!

Um, isn't truncate shorter than 9 bytes...

@JoKing Yes, but it's longer than toInt.

@UnrelatedString I'm a bit confused. The answer for Python (int) or for JavaScript (parseInt) is also not a function (brackets are missed) while the answer fo C is the whole program.

Submissions can be full programs or functions (can be anonymous). The Python and Javascript submissions are functions, however your submission is a snippet since the value of x has to be defined beforehand. If toInt is a function that can be assigned or used as a value, then you can submit just that in the same way. You can also provide a link to an online interpreter so it is easier for other users to test your submission

As far as I can tell, toInt is a string method, so it has to be a lambda (I think), but truncate is just a function, so you can submit it as just truncate for 9 bytes

@JoKing toInt is also a float method. Does this mean that it's only 5 bytes?

Can you do toInt(-5.3)? If so, yes. This also depends on whether Kotlin allows you to use a function as a value, like x = toInt; x(-5.3) or [1,2,3].map(toInt)

@Alex.S You actually don't need the parenthesys for JavaScript, if you use ES6 template string (e.g.: parseInt\-5.5`). Template strings are string literals and some functions treat the numbers as string. In this case, parseInt` is receiving a string (which is what it expects) and outputting an integer. Nothing wrong with the JavaScript solution.

{toInt()} is the cheapest correct way to write this, it's a Float.() -> Int lambda.

TI-BASIC (2 bytes)
iPart(Ans

Hex dump:
B9 72

Explanation:
iPart( truncates its parameter.
Examples:
-5.2
            -5.2
iPart(Ans
              -5
5.2
             5.2
iPart(Ans
               5

Commodore BASIC (C64/128/TheC64Mini, Commodore PET, VIC-20, C16/+4) 37 tokenized and BASIC bytes used
 0inputa:a%=abs(a):ifa<.thena%=-a%
 1?a%

Example input/output:
 1.99 /  1
-1.99 / -1

When converting a numeric value to an integer by declaring a % variable, it zero-fills the bytes after the decimal point, so 1.99 becomes 1.0 on the variable stack; -1.99 will become -2 so I have corrected this in line 0 with the if/then statement.

Visual Basic Script, 3 bytes
Fix

Full program, 20 bytes
MsgBox Fix(InputBox)

x86 machine code (non-trivial), 22 bytes
A routine that rounds an IEEE 754 floating point number in eax.
00000000: c1c8 1788 c180 e97f 7902 31c0 d3c0 80e9  ........y.1.....
00000010: 17f6 d9d3 e0c3                           ......

Try it online! (This wraps the routine sans the final ret in a C++ asm block to make testing easy).
It works by clearing all the bits in the mantissa after the point (just like how you would do it with decimal numbers).
Some examples to show what I mean:
S EEEEEEEE MMMMMMMMMMMMMMMMMMMMMMM
0 10000000 10001100110011001100110 ; ~  3.1, exp = 1
0 10000000 10000000000000000000000 ; =  3.0

0 10000101 10010101100110011001101 ; ~101.4, exp = 6
0 10000101 10010100000000000000000 ; =101.0

Annotated source (NASM format):
[BITS 32]
; 64 bit also works

; truncates an IEEE 754 float in %eax to an integer.
; modifies %eax and %cl
rtz:
    ; circular shift right the float by 23 bits
    ; (size of the mantissa) so the exponent is in al.
    ror eax,23
    ; then put it in cl.
    mov cl,al
    ; subtract 127 from the exponent value to get the
    ; true exponent.
    sub cl,127
    ; if the result is positive, skip the 0 step.
    jns noZero
    ; if the result is negative, then the exponent is
    ; also negative - i.e. the magnitude of the input
    ; is less than 1 - so the result should be 0.
    xor eax,eax
noZero:
    ; circular shift left the float by %cl bits
    ; (the exponent) to truncate the mantissa.
    rol eax,cl
    ; calculate 23 - cl, how many bits we need to
    ; shift back left to realign the float.
    sub cl,23
    neg cl
    ; logical shift left the float by %cl bits.
    ; this zero fills, so the mantissa is truncated.
    shl eax,cl
    ret

Japt -h, 1 byte
õ

Try it here

Lua, 30 bytes
print(((...):gsub('%..*','')))

Try it online!
Unfortunately the integer division operator rounds towards negative infinity... so instead we remove the decimal from the string representation of the input.

Thunno 2, 1 byte
N

Attempt This Online!
Leaves only the integer part.

J-uby, 1 byte
In J-uby Z is an alias for :to_i.
Z

Attempt This Online!