Objectif

Étant donné un nombre d'entrée, arrondissez-le au nombre le plus proche avec un chiffre significatif.

Exigences

Contribution

• Un nombre à virgule flottante.
• Supposons que le numéro d'entrée entraîne une sortie dans les limites du type de données (c.-à-d. Ignorer les erreurs de débordement.)
• 0 est une entrée non valide.
• Les nombres qui ne peuvent pas être représentés avec précision dans le type de données à virgule flottante (par exemple, "0.35"être stockés en tant que 0.3499999) ne doivent pas être pris en charge.

Production

• Le nombre le plus proche composé d'un chiffre différent de zéro et d'un nombre quelconque de chiffres zéro.
• Le résultat doit prendre en charge les nombres négatifs et les nombres fractionnaires.
• Lorsque l'entrée se situe exactement entre deux sorties possibles, arrondissez à zéro.

Présentation

L'accent est mis sur le calcul plutôt que sur la présentation. La sortie peut être un type de données à virgule flottante. Il peut s'agir de texte en entier ou en notation scientifique. Si vous trouvez une faille où la présentation d'une certaine manière réduit votre nombre d'octets, bravo à vous!

Exemples

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

Cas de 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

Notation

Le code avec le moins d'octets après une semaine gagne.

MATL , 3 octets

1&V

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Le cas de test 0.25échoue pour le compilateur exécuté dans Octave sur TIO, mais fonctionne dans Matlab sur Windows:

Le comportement différent est provoqué par la fonction d'Octave / Matlab sprintfutilisant soit "l'arrondi du banquier", soit ".5 loin de zéro", selon la plate-forme. Plus d'informations et de tests peuvent être trouvés ici .

Pour 6 octets ,

1t3$Yo

fonctionne à la fois sur Octave et sur Matlab. Vérifiez tous les cas de test .

C # (.NET Core) , 19 octets

n=>n.ToString("G1")

Essayez-le en ligne!

Exemples:

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 octets

x=>x.toPrecision(1)

Rétine , 63 62 octets

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

Essayez-le en ligne!

PHP , 45 octets

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

Essayez-le en ligne!

Même méthode que ma réponse python 2.

Semble également gérer correctement 0.35, ce qui le place également au-dessus de la réponse JS: D

T-SQL, 27 octets

SELECT FORMAT(i,'G1')FROM t

Utilisation du même code de formatage .Net que la réponse C # de Carlos Alejo . L'entrée provient de la colonne flottante i dans le tableau préexistant t , conformément à nos normes IO

Cas de 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

(Assez pratique que je puisse pré-charger la table d'entrée avec toutes ces valeurs et les exécuter en même temps.)

Python 2 , 62 octets

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

Essayez-le en ligne!

Pas habitué au golf en python, mais cela fonctionne.

Échec en 0.35raison d'inexactitudes en virgule flottante.

Merci à Anders Kaseorg d'avoir souligné que cela fonctionne correctement en Python 2

Guile , 23 octets

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

Essayez-le en ligne!

Excel, 14 octets

=ROUNDUP(A1,1)

Perl 5 , 15 octets

printf"%.1g",<>

Essayez-le en ligne!

Zsh , 14 octets

Port de la réponse perl. Essayez-le en ligne!

printf %.1g $1

Forth (gforth) , 24 octets

: f 1 set-precision f. ;

Essayez-le en ligne!

Une entrée est attendue sur la pile à virgule flottante. La sortie est à stdout

Je n'aime pas apporter de modifications à la précision globale (pour cette instance) des fonctions de sortie en virgule flottante, mais cela économise beaucoup d'octets pour ne pas avoir à restaurer la valeur précédente à la fin. Ne sort pas en ingénierie ou en notation scientifique, quelle que soit l'entrée.

Remarque: Pour une raison quelconque, l'interpréteur tio se convertit 0.25en 0.2, tandis que mon installation locale se convertit 0.25en 0.3. Je ne sais pas exactement pourquoi c'est, mais comme j'obtiens le bon résultat localement, je laisse ma réponse telle quelle

: 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