Obbiettivo

Dato un numero di input, arrotondalo al numero più vicino con una cifra significativa.

Requisiti

Ingresso

• Un numero in virgola mobile.
• Supponiamo che il numero di input generi un output entro i limiti del tipo di dati (es. Ignora errori di overflow.)
• 0 è un input non valido.
• I numeri che non possono essere rappresentati con precisione nel tipo di dati in virgola mobile (ad es. "0.35"Essere archiviati come 0.3499999) non devono essere supportati.

Produzione

• Il numero più vicino costituito da una cifra diversa da zero e un numero qualsiasi di cifre zero.
• Il risultato deve supportare numeri negativi e numeri frazionari.
• Quando l'ingresso si trova esattamente tra due possibili uscite, arrotondare per difetto da zero.

Presentazione

L'attenzione si concentra sul calcolo piuttosto che sulla presentazione. L'output può essere un tipo di dati in virgola mobile. Può essere un testo completo o in notazione scientifica. Se trovi una scappatoia in cui la presentazione in un certo modo riduce il conteggio dei byte, complimenti a te!

Esempi

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

Casi test

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

punteggio

Vince il codice con il minor numero di byte dopo una settimana.

MATL , 3 byte

1&V

Provalo online! Oppure verifica tutti i casi di test .

Il test case 0.25non riesce per il compilatore in esecuzione in Octave su TIO, ma funziona in Matlab su Windows:

Il diverso comportamento è causato dalla funzione di Octave / Matlab sprintfusando l'arrotondamento "arrotondamento del banco" o "arrotondamento da 0,5 a zero", a seconda della piattaforma. Ulteriori informazioni e test sono disponibili qui .

Per 6 byte ,

1t3$Yo

funziona sia su Octave che su Matlab. Verifica tutti i casi di test .

C # (.NET Core) , 19 byte

n=>n.ToString("G1")

Provalo online!

Esempi:

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 byte

x=>x.toPrecision(1)

Retina , 63 62 byte

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

Provalo online!

PHP , 45 byte

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

Provalo online!

Stesso metodo della mia risposta a Python 2.

Sembra anche che gestisca correttamente 0.35, il che lo mette anche al di sopra della risposta JS: D

T-SQL, 27 byte

SELECT FORMAT(i,'G1')FROM t

Utilizzando lo stesso codice di formattazione .Net della risposta C # di Carlos Alejo . L'input proviene dalla colonna float i nella tabella t preesistente , secondo i nostri standard IO

Casi test:

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

(È abbastanza utile poter precaricare la tabella di input con tutti questi valori ed eseguirli contemporaneamente.)

Python 2 , 62 byte

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

Provalo online!

Non usato per giocare a golf in pitone, ma funziona.

Errore a 0.35causa di imprecisioni in virgola mobile.

Grazie ad Anders Kaseorg per aver sottolineato che funziona correttamente in Python 2

Guile , 23 byte

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

Provalo online!

Excel, 14 byte

=ROUNDUP(A1,1)

Perl 5 , 15 byte

printf"%.1g",<>

Provalo online!

Zsh , 14 byte

Porta della risposta perl. Provalo online!

printf %.1g $1

Forth (gforth) , 24 byte

: f 1 set-precision f. ;

Provalo online!

L'ingresso è previsto nello stack in virgola mobile. L'output è su stdout

Non mi piace apportare modifiche alla precisione globale (per questa istanza) delle funzioni di output in virgola mobile, ma consente di risparmiare molti byte per non dover ripristinare il valore precedente alla fine. Non genera in notazione ingegneristica o scientifica, indipendentemente dall'input.

Nota: per qualche motivo, l'interprete tio si converte 0.25in 0.2, mentre la mia installazione locale si converte 0.25in 0.3. Non sono del tutto sicuro del perché, ma dato che ottengo il risultato corretto localmente, sto lasciando la mia risposta così com'è

: 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