Objetivo

Dado un número de entrada, redondee al número más cercano con una cifra significativa.

Requisitos

Entrada

• Un número de coma flotante.
• Suponga que el número de entrada da como resultado una salida dentro de los límites del tipo de datos (es decir, ignore los errores de desbordamiento).
• 0 es una entrada no válida.
• Los números que no se pueden representar con precisión en el tipo de datos de coma flotante (por ejemplo, "0.35"almacenados como 0.3499999) no tienen que ser compatibles.

Salida

• El número más cercano que consta de un dígito distinto de cero y cualquier número de dígitos cero.
• El resultado debe admitir números negativos y números fraccionarios.
• Cuando la entrada se encuentra exactamente entre dos salidas posibles, redondee desde cero.

Presentación

El foco está en el cálculo más que en la presentación. La salida puede ser un tipo de datos de punto flotante. Puede ser texto completo o en notación científica. Si encuentra una escapatoria en la que presentar de cierta manera reduce su número de bytes, ¡felicitaciones!

Ejemplos

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

Casos de prueba

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

Puntuación

El código con el menor recuento de bytes después de una semana gana.

MATL , 3 bytes

1&V

Pruébalo en línea! O verificar todos los casos de prueba .

El caso de prueba 0.25falla para el compilador que se ejecuta en Octave en TIO, pero funciona en Matlab en Windows:

El comportamiento diferente es causado por la función de Octave / Matlab sprintfusando el redondeo de "banquero" o ".5 lejos de cero", dependiendo de la plataforma. Más información y pruebas se pueden encontrar aquí .

Para 6 bytes ,

1t3$Yo

funciona tanto en Octave como en Matlab. Verifique todos los casos de prueba .

C # (.NET Core) , 19 bytes

n=>n.ToString("G1")

Pruébalo en línea!

Ejemplos:

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

Javascript, 19 bytes

x=>x.toPrecision(1)

Retina , 63 62 bytes

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

Pruébalo en línea!

PHP , 45 bytes

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

Pruébalo en línea!

El mismo método que mi respuesta de Python 2.

También parece manejarse correctamente 0.35, lo que lo coloca también sobre la respuesta JS: D

T-SQL, 27 bytes

SELECT FORMAT(i,'G1')FROM t

Usando el mismo código de formato .Net que la respuesta C # de Carlos Alejo . La entrada es de la columna flotante i en la tabla t preexistente , según nuestros estándares IO

Casos de prueba:

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

(Es bastante útil que pueda precargar la tabla de entrada con todos estos valores y ejecutarlos de una vez).

Python 2 , 62 bytes

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

Pruébalo en línea!

No estoy acostumbrado al golf en pitón, pero esto funciona.

Falla 0.35debido a imprecisiones de coma flotante.

Gracias a Anders Kaseorg por señalar que esto funciona correctamente en Python 2

Guile , 23 bytes

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

Pruébalo en línea!

Excel, 14 bytes

=ROUNDUP(A1,1)

Perl 5 , 15 bytes

printf"%.1g",<>

Pruébalo en línea!

Zsh , 14 bytes

Puerto de la respuesta perl. Pruébalo en línea!

printf %.1g $1

Adelante (gforth) , 24 bytes

: f 1 set-precision f. ;

Pruébalo en línea!

Se espera una entrada en la pila de coma flotante. La salida es stdout

No me gusta hacer cambios en la precisión global (para esta instancia) de las funciones de salida de coma flotante, pero ahorra muchos bytes para no tener que restaurar el valor anterior al final. No sale en notación de ingeniería o científica, independientemente de la entrada.

Nota: Por alguna razón, el intérprete de tio se convierte 0.25a 0.2, mientras que mi instalación local se convierte 0.25a 0.3. No estoy completamente seguro de por qué esto es así, pero como obtengo el resultado correcto localmente, dejo mi respuesta tal como está

: 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