# Rounding Numbers

Given a number between 0 and 1 and another integer, print the approximated value of the first number rounded off to the specified number of digits given by the second integer. For example, if the input is 0.3212312312 , 2 then the output is:

0.32 

# Rules

• The number of digits after the dot should always equal the second input integer.

• The input will always be ([)number from 0-1 , integer above 0(])

• Predefined round functions are allowed.

• The first input number will not have any trailing 0's

• Always use a dot for input and output. Commas are not allowed.

• Fractions are allowed as output with the notation number/number but try to just use a decimal notation.

[Trailing zero rule removed due to that i should have been faster]

• Rounding should always be done to the closest number so up if above 4 and down if under 5.

# Testcases

Input: 0.31231231231 , 1

Output: 0.3

Input: 0.1, 10

Output: 0.1000000000

Input: 0.01231231231 , 9

Output: 0.012312312

# Scoring:

This is code-golf. Shortest answer in bytes wins.

Suggestion for making this challenge better are appreciated. Have fun golfing!

EDIT: definition of this challenge by Francisco Hahn: shortest way to round a float X with precision N on each language

Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

/* Configuration */

var QUESTION_ID = 166330; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(a) {
});
comment_page = 1;
}
});
}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
});
else process();
}
});
}

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

function getAuthorName(a) {
return a.owner.display_name;
}

function process() {
var valid = [];

var body = a.body;
if(OVERRIDE_REG.test(c.body))
body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
});

var match = body.match(SCORE_REG);
if (match)
valid.push({
user: getAuthorName(a),
size: +match[2],
language: match[1],
});

});

valid.sort(function (a, b) {
var aB = a.size,
bB = b.size;
return aB - bB
});

var languages = {};
var place = 1;
var lastSize = null;
var lastPlace = 1;
valid.forEach(function (a) {
if (a.size != lastSize)
lastPlace = place;
lastSize = a.size;
++place;

.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)

var lang = a.language;
if (/<a/.test(lang)) lang = jQuery(lang).text();

languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
});

var langs = [];
for (var lang in languages)
if (languages.hasOwnProperty(lang))
langs.push(languages[lang]);

langs.sort(function (a, b) {
if (a.lang > b.lang) return 1;
if (a.lang < b.lang) return -1;
return 0;
});

for (var i = 0; i < langs.length; ++i)
{
var language = jQuery("#language-template").html();
var lang = langs[i];
language = language.replace("{{LANGUAGE}}", lang.lang)
.replace("{{NAME}}", lang.user)
.replace("{{SIZE}}", lang.size)
language = jQuery(language);
jQuery("#languages").append(language);
}

}
body { text-align: left !important}

width: 290px;
float: left;
}

#language-list {
width: 290px;
float: left;
}

font-weight: bold;
}

table td {
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>

</tbody>
</table>
</div>
<div id="language-list">
<h2>Winners by Language</h2>
<table class="language-list">
<tr><td>Language</td><td>User</td><td>Score</td></tr>
<tbody id="languages">

</tbody>
</table>
</div>
<table style="display: none">
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
</tbody>
</table>

• Very closely related, potential duplicate. Since my vote is a hammer, I won't vote to close as yet. Jun 6, 2018 at 15:14
• @AdmBorkBork as far as i see the other question handles significative values of the float, this one doesn't, but i can see this post as something like shortest way to round a float X with precision N on each language Jun 6, 2018 at 15:22
• "Rounding should always be done to the closest number so up if above 4 and down if under 5." Most languages use the round-to-even standard (2.5 rounds to 2). If you enforce this requirement, I'm not sure any of the proposed solutions are correct. Jun 6, 2018 at 16:13
• Suggestion: test cases with rounding
– Jo King
Jun 6, 2018 at 18:22
• @12Me21: As noted on said answers, 0.02675 is not a "real" number; the actual value is 0.02674999999999..., so rounding down is correct here, regardless of rounding strategy. Jun 6, 2018 at 18:58

# APL (Dyalog Unicode), 1 byteSBCS

Anonymous tacit infix function (actually just a built-in). Takes number of decimals as left argument and fraction as right argument.

⍕


Try it online!

Documentation for dyadic ⍕ ("Format By Specification").

• I like how you treat that built-in so formally over TIO... Jun 6, 2018 at 17:07
• I'm not sure if this fits the challenge as this requires a f as input instead of a , (atleast on TIO) Jun 6, 2018 at 19:37
• @LucH APL is usually used in an interactive session (REPL). TIO's Code area contains the actual definition(s) while Input is the session where the "user" uses the function f.
Jun 6, 2018 at 20:03

# JavaScript (Node.js), 18 bytes

a=>b=>a.toFixed(b)


Try it online!

• lol, this is just nice :) Jun 6, 2018 at 15:13

# Japt, 2 bytes

xV


Try it online!

x is the builtin for rounding to n decimals. We pass in V (Second input).

• Okay... I don't think this can be beat lol. Jun 6, 2018 at 15:19
• Dang it! Too slow! Jun 6, 2018 at 15:22
• tio.run/##y0osKPn/vyLs/38DPQNDI2MoUtBRMAIA maybe use that notation for input in your tio as your current version wasn't according to the challenge rules. (code is the same, just changed the input) Jun 6, 2018 at 15:23
• @LucH - that's irrelevant in Japt each comma or newline separated item is a separate input. Jun 6, 2018 at 15:26
• Fails on 0.02675, 4 Jun 6, 2018 at 18:29

# Japt, 2 bytes

Takes input as an array of 2 numbers.

rx


Try it

reduces the array by rounding the first number to the number of decimals specified by the second.

• Japt just seems to be too good for this challenge. Jun 6, 2018 at 15:25
• Upvoting this answer because it is smaller than the other Japt answer: this one uses only lowercase characters.
– Jeff
Jun 6, 2018 at 20:31

# PHP, 47 39 bytes

function a($b,$c){return round($b,$c);}


Try it online!

• How many languages are you going to golf this in? ;) Jun 6, 2018 at 15:16
• @LucH 2 is nothing try seeing Leaky's 10 answer combo :D Jun 6, 2018 at 15:16
• @LucH The challenge is too easy. xD sorry Jun 6, 2018 at 15:17
• @LuisfelipeDejesusMunoz codegolf.stackexchange.com/questions/120052/… that one was easy and it blew up so that's why i also made this one. Jun 6, 2018 at 15:19
• Are you sure you can pass the arguments like that toa php script?, it is my understanding that the values has to be on the $argv array as arguments for the script. Jun 6, 2018 at 15:44 # Python 3 (produces rounded float, no trailing zeroes), 5 bytes round  Try it online! Python's built-in round function is defined to do exactly what the OP wants in the summary edited in later "round a float X with precision N", though without appending trailing zeroes (because it's still returning a float, and floats don't include information about their formatting). # Python 3 (produces string form), 16 bytes '{:.{}f}'.format  Try it online! Formatting operations can use a nested specifier to allow one argument to define the precision of the other. Doesn't print it, but returns a formatted string with the specified precision. # Python 3 (prints string), 30 bytes lambda a,b:print(f'{a:.{b}f}')  Try it online! Python 3.6+ f-strings save some characters here (couldn't use them without the wrapping function since we wouldn't know the names to use). Mostly included to demonstrate f-strings (obviously longer than other solutions). • Note: The behavior of round() for floats can be surprising: for example, round(2.675, 2) gives 2.67 instead of the expected 2.68. This is not a bug: it’s a result of the fact that most decimal fractions can’t be represented exactly as a float. See Floating Point Arithmetic: Issues and Limitations for more information.  Jun 6, 2018 at 18:25 • @12Me21: This is a problem in any language based on IEEE binary floating point. If 2.675 doesn't really exist, it's just a shorter spelling of 2.6749999999999999996 or whatever, then you've rounded correctly. Python isn't unique here, it's just up front about the problem in the docs, where many languages don't bother to mention it. Jun 6, 2018 at 18:37 # Python 2, 24 bytes -4 bytes thanks to ovs lambda a,b:"%%0.%sf"%b%a  Try it online! • Fails on 0.02675, 4 Jun 6, 2018 at 18:36 • @12Me21: Not relevant, since 0.02675 doesn't actually exist as an exact value in IEEE 754 binary64 floating point (which most languages use as the basis for floating point math; you'll get the same issues with Java, JavaScript, C#, C [compiler dependent], etc.). The closest value is something like 0.02674999999999999947, with 0.02675 being a convenient shorthand. Floating point math is broken from a human perspective Jun 6, 2018 at 18:53 • 24 bytes – ovs Jun 7, 2018 at 1:49 • @ovs: Using more modern formatting (i.e. the str.format method, not printf-style formatting), you can get it down to 16 bytes (doesn't even require a lambda). My second solution for Python 3 will work identically in Python 2.7 (and only require two more bytes on Python 2.6, to add indices to the formatting placeholders). Jun 7, 2018 at 14:59 ## PHP, 28 Bytes Try it online Code <?=round($argv[0],$argv[1]);  # Forth (gforth), 26 bytes Assuming decimal is on top of the floating point stack and precision is on the integer stack : f dup 2 + swap 1 f.rdp ;  Try it online! ### Explanation f.rdp takes a float and 3 arguments from the integer stack: 1. the width of the output (answer uses n+2 to account for 0 and decimal point) 2. the number of digits after the decimal (answer uses n) 3. the required number of significant figures in the input (answer uses 1, because floats with less significant figures are outputted in exponential notation) ### Code explanation dup 2 + swap 1 \ place n+2 n and 1 on top of the stack f.rdp \ formats output  # Stax, 1 bytes j  Run and debug it In stax, j is a built-in instruction that performs the required rounding. # T-SQL, 24 bytes SELECT STR(f,20,d)FROM t  Per our input standards, input is taken via pre-existing table t with float f and integer d. The function STR() is shorter and more convenient than either a CAST or a ROUND. You didn't specify, so I assumed that 20 digits would be more than sufficient. If not, that hard-coded value can be increased. # Java (JDK 10), 21 bytes n->d->n.setScale(d,4)  Try it online! I would have loved to have submitted n->n::setScale (14 bytes) but alas, there is no default rounding, so we get ArithmeticException when rounding is required... # MATL, 13 bytes i'%.'j'f'hhYD  Try it online! ### Explanation: i % Grab first input: 0.32315 '%.'j'f' % Push the literal: ['%.' second input as string 'f'], where the input % specifies the number of decimals YD % printf('%.sf',x) where s is the second input, and x is the first  • hh seems to be missing from the explanation. Also, I think you can remove i if you change the input order Jun 7, 2018 at 22:07 # R, 40 36 bytes function(x,n)format(round(x,n),ns=n)  Try it online! (-4) thanks to digEmAll • You can use partial matching for arguments, i.e. nsmall=n can be shortened to ns=n Jun 7, 2018 at 9:35 # Julia 0.6, 51 bytes (x,d)->(y=string(round(x, d));y*"0"^(d-endof(y)+2))  Try it online! With trailing zeros as per the questions's "Trailing zeroes should be added with for example 0.1, 10" condition. Julia's @printf can only take constant X values in %.Xf format strings (%.4f, etc.), so instead this code manually pads the required number of zeros if the rounded value has less than d digits after the decimal place. First, store the rounded number as a string in y. Then, the number of digits after decimal point in y is length(y) - 2 (- 2 because the inputs are between 0 and 1, so there's one initial digit and then a decimal point to subtract). endof(y) is just a shorter way to write length(y) (at least for Julia v0.6). Then, subtract this from the required number of digits d. Then, (d-(endof(y)-2)) (= (d-endof(y)+2)) tells you how many digits are missing in the output (if any). Use that in "0"^(d-endof(y)+2) to get "0" repeated that many times, and then append that to y with the string * (concatenate) operator. # Julia 0.6, 5 bytes round  Try it online! Without trailing zeros, conforming to the summary "shortest way to round a float X with precision N on each language". • Could you use two printf like this 43 bytes R solution? Jun 7, 2018 at 17:52 • Doesn't seem possible, unfortunately. The problem is that Julia's @printf parses its format string at compile time (for doing some type system magic), and as such requires the whole format string to be a compile-time constant. There are external packages to allow C-style or Python-style full-fledged format strings, but nothing builtin as of now. Jun 7, 2018 at 18:04 • Thanks for the clarification - I get now what you meant by constant above. Too bad! Jun 7, 2018 at 18:18 74 Bytes Python 2.7 lambda x,y:str(x)[:y+2]if int(str(x)[y+2])<5else float(str(x)[:y+2])+.1**y  Messy but I think it works for all the scenarios. • Welcome to PPCG! :) Jun 6, 2018 at 16:12 • It fails if the y is greater than the precision of x: tio.run/##PYzBCsIwEETvfsVSCGTTUJqCl2K/… Jun 6, 2018 at 16:20 # Perl 6, 18 bytes {$^a.base(10,$^b)}  Try it # 05AB1E, 10 bytes .ò0¹²g-Ì∍J  .ò is the builtin that already gives the answer for most test cases. 0¹²g-Ì∍J is to correctly append trailing zeroes if necessary. .ò # Round the second decimal input to the integer first input amount of decimals # i.e. 10 and 0.1 → 0.1 # i.e. 1 and 0.67231 → 0.7 0 # Literal '0' ¹ # Get the first integer input ²g # Get the length of the second decimal input - # Subtract them from each other Ì # Increase it by 2 for the "0." part # i.e. 10 and 0.1 → 10-3+2 → 9 # i.e. 1 and 0.67231 → 1-7+2 → -8 ∍ # Extend the "0" to a size of that length # i.e. "0" and 9 → "000000000" # i.e. "0" and -8 → '' J # Join everything together # i.e. 0.1 and "000000000" → 0.1000000000 # i.e. 0.7 and '' → 0.7  # Octave, 28 bytes @(x,y)printf(['%.',y,'f'],x)  Try it online! Takes the first input as a number and the second as a string. Creates a formatting string: %.yf by concatenation, where y is the input that specifies the number of decimals. x is the input number that will be printed. # R, 42 bytes function(x,n)sprintf(paste0("%.",n,"f"),x)  Try it online! Failed attempt at outgolfing DS_UNI's shorter R answer. Even worse: ## R, 43 bytes function(x,n)sprintf(sprintf("%%.%if",n),x)  Try it online! # Kotlin, 19 bytes "%.${b}f".format(a)


Try it online!

• By default, submissions should be either a function or a full program. This is just a snippet that needs predefined variables a and b.
– Jo King
Jun 9, 2018 at 13:22

# Tcl, 31 bytes

proc R x\ n {format %.*f $n$x}


Try it online!