Commatizing numbers: Difference between revisions

{{task|Arithmetic operations}}

 

''Commatizing''   numbers (as used here, is a handy expedient made-up word) is the act of adding commas to a number (or string), or to the numeric part of a larger string.

::::::* &nbsp; 7500<b>∙</b>10**35

::::::* &nbsp; 8500x10**35

::::::* &nbsp; +55000↑3

::::::* &nbsp; 1000**100

;Also see:

* The Wiki entry: &nbsp; [http://en.wikipedia.org/wiki/Eddington_number (sir) Arthur Eddington's number of protons in the universe]. <br><br>

 

=={{header|ALGOL 68}}==

# period, location and separator paramters #

PROC commatize = ( STRING text, INT location, INT period, STRING separator )STRING:

newline ) );

print( ( COMMATIZE " $-140000±100 millions.", newline ) );

{{out}}

<pre>

 

=={{header|C sharp|C#}}==

static string[] inputs = {

"pi=3.14159265358979323846264338327950288419716939937510582097494459231",

}

}

 

=={{header|D}}==

Better to have more tests than more features.

 

auto commatize(in char[] txt, in uint start=0, in uint step=3,

foreach (const line; "commatizing_numbers_using_defaults.txt".File.byLine)

line.commatize.writeln;

{{out}}

<pre>pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231

$-140,000±100 millions.

6/9/1946 was a good year for some.</pre>

 

=={{header|Factor}}==

{{works with|Factor|0.99 2020-01-23}}

splitting strings unicode ;

 

" $-140000±100 millions."

"6/9/1946 was a good year for some."

{{out}}

<pre>

6/9/1946 was a good year for some.

</pre>

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Println(commatize(test, 0, 3, ","))

}

 

{{out}}

{{Works with|GHC|8.6.5}}

 

 

import Control.Monad (forM_)

putStrLn str

putStrLn $ commatize str by sep

{{out}}

<pre>

These rules are relatively baroque, which demands long names and minimally complex statements, thus:

 

commatize=:3 :0"1 L:1 0

(i.0) commatize y

fixed=. numb,;delim&,each (-period)<\ (#numb)}.number

prefix,(start{.text),fixed,(start+len)}.text

 

In use, this might look like:

 

pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231

'.' commatize 'The author has two Z$100000000000000 Zimbabwe notes (100 trillion).'

$-140,000±100 millions.

commatize '6/9/1946 was a good year for some.'

 

=={{header|Java}}==

import java.util.*;

import java.util.regex.*;

System.out.println(m.appendTail(result));

}

 

<pre>pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231

$-140,000±100 millions.

6/9/1946 was a good year for some.</pre>

 

=={{header|Julia}}==

{{trans|Perl}}

["pi=3.14159265358979323846264338327950288419716939937510582097494459231", " ", 5],

[raw"The author has two Z$100000000000000 Zimbabwe notes (100 trillion).", "."],

println(commatize(tst))

end

pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231

The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).

 

=={{header|Kotlin}}==

 

val r = Regex("""(\.[0-9]+|[1-9]([0-9]+)?(\.[0-9]+)?)""")

println(tests[4].commatize(sep = "."))

for (test in tests.drop(5)) println(test.commatize())

 

{{out}}

This is a translation of the Kotlin (and Go) algorithm with some modifications.

 

import strutils

 

for i in countup(ip.high mod period + 1, ip.high, period):

ip.insert(sep, i + inserted)

 

# Process decimal part.

 

for n in 5..Tests.high:

 

{{out}}

=={{header|Perl}}==

Displaying before/after only when changes applied.

['pi=3.14159265358979323846264338327950288419716939937510582097494459231', ' ', 5],

['The author has two Z$100000000000000 Zimbabwe notes (100 trillion).', '.'],

$c =~ s/$sep$//;

return reverse $c;

{{out}}

<pre>pi=3.14159265358979323846264338327950288419716939937510582097494459231

 

=={{header|Phix}}==

{{Out}}

<pre>

 

=={{header|Python}}==

import re as RegEx

 

print ( Commatize( "␢␢␢$-140000±100 millions." ))

print ( Commatize( "6/9/1946 was a good year for some." ))

 

=={{header|Racket}}==

All tests pass (so it's as good as Perl, I guess).

 

(require (only-in srfi/13 [string-reverse gnirts]))

 

(commatize "6/9/1946 was a good year for some.")

=>"6/9/1946 was a good year for some."))

 

=={{header|Raku}}==

(formerly Perl 6)

('The author has two Z$100000000000000 Zimbabwe notes (100 trillion).', {:ins<.>}),

'-in Aus$+1411.8millions',

$s.subst: :continue($at), :1st, / <[1..9]> <[0..9]>* /,

*.flip.comb(/<{ ".**1..$by" }>/).join($ins).flip;

{{out}}

<pre>Before: pi=3.14159265358979323846264338327950288419716939937510582097494459231

=={{header|REXX}}==

The hardest part of the &nbsp; '''comma''' &nbsp; function is to locate where a &nbsp; ''usable'' &nbsp; number starts and ends.

@. =

@.1= "pi=3.14159265358979323846264338327950288419716939937510582097494459231"

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<pre>

=={{header|Scala}}==

===Java-ish version===

import java.util.Scanner

import java.util.regex.Pattern

val sc = new Scanner(new File("input.txt"))

while (sc.hasNext) commatize(sc.nextLine)

 

=={{header|Swift}}==

{{trans|Kotlin}}

 

 

extension String {

for testCase in tests.dropFirst(5) {

print(testCase.commatize())

 

{{out}}

=={{header|VBA}}==

{{trans|Phix}}

Dim l As Integer: l = Len(s)

For i = start To l

commatize " $-140000±100 millions."

commatize "6/9/1946 was a good year for some."

<pre>pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231

The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).

$-140,000±100 millions.

6/9/1946 was a good year for some.</pre>

 

=={{header|Wren}}==

var addSeps = Fn.new { |n, dp|

var lz = ""

]

 

 

{{out}}