Getting the number of decimal places: Difference between revisions

{{draft task}}

;Task:

 

 

{{trans|Python}}

 

R I ‘.’ C n {n.split(‘.’).last.len} E 0

 

print(dec(‘12.345’))

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

BYTE FUNC FindC(CHAR ARRAY s CHAR c)

ValR("1.E-10",r) Test(r)

ValR("1.23456789E10",r) Test(r)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Getting_the_number_of_decimals.png Screenshot from Atari 8-bit computer]

1.23456789E+10 has 0 decimals

</pre>

 

=={{header|AutoHotkey}}==

output .= v " has " StrLen(StrSplit(v, ".").2) " decimals.`n"

{{out}}

<pre>10 has 0 decimals.

 

=={{header|AWK}}==

# syntax: GAWK -f GETTING_THE_NUMBER_OF_DECIMALS.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

=={{header|C}}==

 

}

 

}

 

int main() {

return 0;

{{out}}

 

=={{header|C++}}==

{{trans|C}}

 

}

 

}

 

int main() {

return 0;

{{out}}

12.345 has 3 decimals

 

 

=={{header|FreeBASIC}}==

Dim As String c = Str(n)

Return Iif(Instr(c, "."), Len(Mid(c,Instr(c, ".")+1)), 0)

Print n(i); " has "; dec(n(i)); " decimals"

Next i

{{out}}

<pre> 7 has 0 decimals

12.345677 has 6 decimals

0.142857142857142 has 15 decimals</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

}

}

 

{{out}}

</pre>

=={{Header|Haskell}}==

decimal [] = 0

decimal ('.':xs) = length xs

numDecimal = decimal . show

 

{{out}}

<pre>[1,3,3,12,15,7]</pre>

=={{header|Java}}==

String str = String.valueOf(x);

if(str.endsWith(".0")) return 0;

else return (str.substring(str.indexOf('.')).length() - 1);

 

=={{header|Julia}}==

s = lowercase(str)

if 'e' in s

println("$n has $(postprecision(n)) decimals.")

end

<pre>

0.00100 has 5 decimals.

=={{header|Kotlin}}==

{{trans|Java}}

val str = x.toString()

if (str.endsWith(".0")) {

println("%f has %d decimals".format(n, findNumOfDec(n)))

}

{{out}}

<pre>12.000000 has 0 decimals

A first answer could be

 

{W.length

{S.rest

{S.replace \. by space in 12.3450}}}

-> 4

 

This is a better one, if considering that ending zeroes should not be considered as decimals

 

{def decimals

{def decimals.r

{decimals 12.34560001230000}

-> 10

Numbers can be of any size.

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

DecimalDigits[r_String] := Module[{pos},

If[StringContainsQ[r, "."],

DecimalDigits["3128"]

DecimalDigits["13."]

{{out}}

<pre>3

=={{header|Perl}}==

Need pragma <code>bignum</code> to handle decimals beyond 15 digits.

 

printf "Fractional precision: %2s Number: %s\n", length((split /\./, $_)[1]) // 0, $_

{{out}}

<pre>Fractional precision: 0 Number: 9

 

=={{header|Phix}}==

{{out}}

32 bit

=={{header|Python}}==

Treated as a function over a string representation of a number to allow the capturing of significant trailing zeros.

...: return len(n.rsplit('.')[-1]) if '.' in n else 0

 

Out[8]: 4

 

 

 

Or, defining a slightly less partial function, over a given number, rather than a string:

 

 

import math

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Decimal counts in stringifications of real and imaginary components:

want to retain them, you need to pass the value as a string. (As below.)

 

 

printf "Fractional precision: %-2s || Number: %s\n", (.split('.')[1] // '').chars, $_

for 9, 12.345, '12.3450', 0.1234567890987654321, (1.5**63).precise;

{{out}}

<pre>Fractional precision: 0 || Number: 9

 

Any number specified in exponential notation is first converted to a whole or fractional integer &nbsp; (or an integer with scale), <br>and &nbsp;that&nbsp; number is then examined.

numeric digits 1000 /*ensure enuf dec digs for calculations*/

@.=; /*initialize a stemmed array to nulls. */

end

parse var x '.' fract /*parse number, get the fractional part*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Testing the function

decimals(2) # Unsensitive to the default setting of decimals

ok

end

{{out}}

<pre>

4

</pre>

 

=={{header|Sidef}}==

var prec = Num(Num!PREC)>>2

var prev = ''

var c = number_of_decimals(n)

say "Number of decimals: #{'%3s' % c} Number: #{n}"

 

{{out}}

 

Converting the fourth example to a Rat or BigRat object wouldn't help as the constructor for those classes automatically reduces the numerator and denominator to their lowest terms. BigRat would work for the fifth example but the argument would have to be passed as a string anyway so we might as well just parse the string.

 

var getNumDecimals = Fn.new { |n|

var ns = (n is String) ? "\"%(n)\"" : "%(n)"

System.print("%(ns) has %(d) decimals")

 

{{out}}