Round like a Zero

Question

Goal

Given an input number, round it off to the nearest number with one significant figure.

Requirements

Input

• A floating point number.
• Assume the input number results in an output within the data type's limits (ie. ignore overflow errors.)
• 0 is an invalid input.
• Numbers that cannot be accurately represented in the floating point data type (eg. "0.35" being stored as 0.3499999) do not have to be supported.

Output

• The nearest number that consists of one non-zero digit and any number of zero digits.
• The result must support negative numbers and fractional numbers.
• When the input lies exactly between two possible outputs, round away from zero.

Presentation

The focus is on the calculation rather than the presentation. The output may be a floating point data type. It may be text either in full or in scientific notation. If you find a loophole where presenting a certain way reduces your byte count, kudos to you!

Examples

9
-3000
.2
0.2
-.2
7e12
5e-15
1e0

Test Cases

Input     Output
1         1
10        10
17        20
99        100
54321     50000
56789     60000
-123      -100
-789      -800
0.23      0.2
0.25      0.3
-0.25     -0.3
4.56e23   5e23
4.56e-23  5e-23

Scoring

The code with the least byte-count after one week wins.

Answer 1

C# (.NET Core), 19 12 bytes

n=>$"{n:G1}"

Try it online!

Examples:

Input     Output
----------------
 54321     5E+04
-56789    -6E+04
 99        1E+02
 0.23      0.2
 0.25      0.3
-0.25     -0.3
 4.56e23   5E+23
 4.56e-23  5E-23

With the new versions of C# we also got shorter ways to achieve this, as Calculuswhiz wisely noted in the comments.

Answer 2

Javascript, 19 bytes

x=>x.toPrecision(1)

Answer 3

MATL, 3 bytes

1&V

Try it online! Or verify all test cases.

Test case 0.25 fails for the compiler running in Octave on TIO, but works in Matlab on Windows:

The different behaviour is caused by Octave's/Matlab's sprintf function using either "banker's rounding" or ".5 away from zero" rounding, depending on platform. More information and tests can be found here.

---

For 6 bytes,

1t3$Yo

works both on Octave and on Matlab. Verify all test cases.

Answer 4

Retina, 63 62 bytes

1`[1-9]
$*#
#\.?[5-9]
#$&
T`d`0`#[\d.]+
0(\.?)#{10}
1$1
#+
$.0

Try it online!

Answer 5

PHP, 45 bytes

<?=round($x=$argv[1],-floor(log10(abs($x))));

Try it online!

Same method as my python 2 answer.

Also seems to correctly handle 0.35, which puts it a peg above the JS answer too :D

Answer 6

T-SQL, 27 bytes

SELECT FORMAT(i,'G1')FROM t

Using the same .Net formatting code as Carlos Alejo's C# answer. Input is from float column i in pre-existing table t, per our IO standards

Test cases:

Input         Output
------------ --------
1             1
10            1E+01
17            2E+01
99            1E+02
54321         5E+04
56789         6E+04
-123         -1E+02
-789         -8E+02
0.23          0.2
0.25          0.3
-0.25        -0.3
4.56E+23      5E+23
4.56E-23      5E-23

(Pretty handy that I can pre-load the input table with all these values and run them at once.)

Answer 7

Excel 2016, 36

• Input A1.
• A2: =10^INT(LOG10(ABS(A1
• Result: =A2*ROUND(A1/A2,

Answer 8

Python 2, 62 bytes

lambda x:round(x,-int(floor(log10(abs(x)))))
from math import*

Try it online!

Not used to python golfing, but this works.

Fails on 0.35 due to floating point inaccuracies.

Thanks to Anders Kaseorg for pointing out that this works correctly in Python 2

Answer 9

Guile, 23 bytes

(format #t"~,0e"(read))

Try it online!

Answer 10

Perl 5, 15 bytes

printf"%.1g",<>

Try it online!

Answer 11

Zsh, 14 bytes

Port of the perl answer. Try it Online!

printf %.1g $1

Answer 12

Forth (gforth), 24 bytes

: f 1 set-precision f. ;

Try it online!

Input is expected on the floating point stack. Output is to stdout

I don't like making changes to the global (for this instance) precision of the floating point output functions, but it saves a lot of bytes to not have to restore the previous value at the end. Does not output in engineering or scientific notation, regardless of input.

Note: For some reason, the tio interpreter converts 0.25 to 0.2, while my local installation converts 0.25 to 0.3. I'm not entirely sure why this is, but since I get the correct result locally, I'm leaving my answer as-is

: f                   \ start a new word definition
  1 set-precision     \ set the floating point output words to use 1 significant digit
  f.                  \ output the top of the floating point stack
;                     \ end the word definition