Rosetta Code

Commatizing numbers: Difference between revisions

Page Discussion

Commatizing numbers (view source)

Revision as of 11:45, 20 November 2023

50,089 bytes added ,  6 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(43 intermediate revisions by 19 users not shown)
Line 1:
{{task|Arithmetic operations}}
<!-- commatiz or commatize !-->
 
''Commatizing'' &nbsp; 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.
 
 
Line 40 ⟶ 41:
::::::* &nbsp; 7500<b>∙</b>10**35
::::::* &nbsp; 8500x10**35
::::::* &nbsp; 9500↑35
::::::* &nbsp; +55000↑3
::::::* &nbsp; 1000**100
Line 78 ⟶ 80:
 
;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|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="11l">F commatize(s, period = 3, sep = ‘,’)
V m = re:‘(\.[0-9]+|[1-9]([0-9]+)?(\.[0-9]+)?)’.search(s)
I !m
R s
 
V match = m.group()
V splits = match.split(‘.’)
 
V ip = splits[0]
I ip.len > period
V inserted = 0
L(i) ((ip.len - 1) % period + 1 .< ip.len).step(period)
ip = ip[0 .< i + inserted]‘’sep‘’ip[i + inserted ..]
inserted += sep.len
 
I splits.len > 1
V dp = splits[1]
I dp.len > period
L(i) ((dp.len - 1) I/ period * period .< period - 1).step(-period)
dp = dp[0 .< i]‘’sep‘’dp[i..]
ip ‘’= ‘.’dp
 
R s[0 .< m.start()]‘’ip‘’s[m.end()..]
 
V tests = [‘123456789.123456789’,
‘.123456789’,
‘57256.1D-4’,
‘pi=3.14159265358979323846264338327950288419716939937510582097494459231’,
‘The author has two Z$100000000000000 Zimbabwe notes (100 trillion).’,
‘-in Aus$+1411.8millions’,
‘===US$0017440 millions=== (in 2000 dollars)’,
‘123.e8000 is pretty big.’,
‘The land area of the earth is 57268900(29% of the surface) square miles.’,
‘Ain't no numbers in this here words, nohow, no way, Jose.’,
‘James was never known as 0000000007’,
‘Arthur Eddington wrote: I believe there are ’""
‘15747724136275002577605653961181555468044717914527116709366231425076185631031296’""
‘ protons in the universe.’,
‘ $-140000±100 millions.’,
‘6/9/1946 was a good year for some.’]
 
print(commatize(tests[0], period' 2, sep' ‘*’))
print(commatize(tests[1], period' 3, sep' ‘-’))
print(commatize(tests[2], period' 4, sep' ‘__’))
print(commatize(tests[3], period' 5, sep' ‘ ’))
print(commatize(tests[4], sep' ‘.’))
 
L(test) tests[5..]
print(commatize(test))</syntaxhighlight>
 
{{out}}
<pre>
1*23*45*67*89.12*34*56*78*9
.123-456-789
5__7256.1D-4
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).
-in Aus$+1,411.8millions
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
$-140,000±100 millions.
6/9/1946 was a good year for some.
</pre>
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68"># returns text commatized according to the rules of the task and the #
# period, location and separator paramters #
PROC commatize = ( STRING text, INT location, INT period, STRING separator )STRING:
Line 167 ⟶ 240:
newline ) );
print( ( COMMATIZE " $-140000±100 millions.", newline ) );
print( ( COMMATIZE "6/9/1946 was a good year for some.", newline ) )</langsyntaxhighlight>
{{out}}
<pre>
Line 183 ⟶ 256:
</pre>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">
static string[] inputs = {
"pi=3.14159265358979323846264338327950288419716939937510582097494459231",
Line 233 ⟶ 306:
}
}
</syntaxhighlight>
</lang>
 
=={{header|D}}==
Better to have more tests than more features.
<langsyntaxhighlight lang="d">import std.stdio, std.regex, std.range;
 
auto commatize(in char[] txt, in uint start=0, in uint step=3,
Line 291 ⟶ 364:
foreach (const line; "commatizing_numbers_using_defaults.txt".File.byLine)
line.commatize.writeln;
}</langsyntaxhighlight>
{{out}}
<pre>pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
Line 304 ⟶ 377:
$-140,000±100 millions.
6/9/1946 was a good year for some.</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.RegularExpressions}}
{{libheader| system.StrUtils}}
{{Trans|Go}}
<syntaxhighlight lang="delphi">
program Commatizing_numbers;
 
{$APPTYPE CONSOLE}
 
uses
System.SysUtils,
System.RegularExpressions,
system.StrUtils;
 
const
PATTERN = '(\.[0-9]+|[1-9]([0-9]+)?(\.[0-9]+)?)';
TESTS: array[0..13] of string = ('123456789.123456789', '.123456789',
'57256.1D-4', 'pi=3.14159265358979323846264338327950288419716939937510582097494459231',
'The author has two Z$100000000000000 Zimbabwe notes (100 trillion).',
'-in Aus$+1411.8millions', '===US$0017440 millions=== (in 2000 dollars)',
'123.e8000 is pretty big.',
'The land area of the earth is 57268900(29% of the surface) square miles.',
'Ain''t no numbers in this here words, nohow, no way, Jose.',
'James was never known as 0000000007',
'Arthur Eddington wrote: I believe there are ' +
'15747724136275002577605653961181555468044717914527116709366231425076185631031296' +
' protons in the universe.', ' $-140000±100 millions.',
'6/9/1946 was a good year for some.');
 
var
regex: TRegEx;
 
function Commatize(s: string; startIndex, period: integer; sep: string): string;
var
m: TMatch;
s1, ip, pi, dp: string;
splits: TArray<string>;
i: integer;
begin
regex := TRegEx.Create(PATTERN);
 
if (startIndex < 0) or (startIndex >= s.Length) or (period < 1) or (sep.IsEmpty) then
exit(s);
m := regex.Match(s.Substring(startIndex, s.Length));
if not m.Success then
exit(s);
 
s1 := m.Groups[0].Value;
splits := s1.Split(['.']);
 
ip := splits[0];
 
if ip.Length > period then
begin
pi := ReverseString(ip);
i := ((ip.Length - 1) div period) * period;
 
while i >= period do
begin
pi := pi.Substring(0, i) + sep + pi.Substring(i);
i := i - period;
end;
ip := ReverseString(pi);
end;
 
if s1.Contains('.') then
begin
dp := splits[1];
if dp.Length > period then
begin
i := ((dp.Length - 1) div period) * period;
while i >= period do
begin
dp := dp.Substring(0, i) + sep + dp.Substring(i);
i := i - period;
end;
end;
ip := ip + '.' + dp;
end;
Result := s.Substring(0, startIndex) + s.Substring(startIndex).Replace(s1, ip, []);
end;
 
var
i: integer;
 
begin
Writeln(commatize(TESTS[0], 0, 2, '*'));
Writeln(commatize(TESTS[1], 0, 3, '-'));
Writeln(commatize(TESTS[2], 0, 4, '__'));
Writeln(commatize(TESTS[3], 0, 5, ' '));
Writeln(commatize(TESTS[4], 0, 3, '.'));
for i := 5 to High(TESTS) do
Writeln(commatize(TESTS[i], 0, 3, ','));
readln;
end.</syntaxhighlight>
 
=={{header|Factor}}==
{{works with|Factor|0.99 2020-01-23}}
<syntaxhighlight lang="factor">USING: accessors grouping io kernel math regexp sequences
splitting strings unicode ;
 
: numeric ( str -- new-str )
R/ [1-9][0-9]*/ first-match >string ;
 
: commas ( numeric-str period separator -- str )
[ reverse ] [ group ] [ reverse join reverse ] tri* ;
 
: (commatize) ( text from period separator -- str )
[ cut dup numeric dup ] 2dip commas replace append ;
 
: commatize* ( text from period separator -- str )
reach [ digit? ] any? [ (commatize) ] [ 3drop ] if ;
 
: commatize ( text -- str ) 0 3 "," commatize* ;
 
"pi=3.14159265358979323846264338327950288419716939937510582097494459231"
5 5 " " commatize* print
"The author has two Z$100000000000000 Zimbabwe notes (100 trillion)."
0 3 "." commatize* print
{
"\"-in Aus$+1411.8millions\""
"===US$0017440 millions=== (in 2000 dollars)"
"123.e8000 is pretty big."
"The land area of the earth is 57268900(29% of the surface) square miles."
"Ain't no numbers in this here words, nohow, no way, Jose."
"James was never known as 0000000007"
"Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe."
" $-140000±100 millions."
"6/9/1946 was a good year for some."
} [ commatize print ] each</syntaxhighlight>
{{out}}
<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).
"-in Aus$+1,411.8millions"
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
$-140,000±100 millions.
6/9/1946 was a good year for some.
</pre>
 
 
=={{header|FreeBASIC}}==
{{trans|VBA}}
{{trans|Phix}}
<syntaxhighlight lang="freebasic">Sub commatize(s As String, sep As String = ",", start As Byte = 1, paso As Byte = 3)
Dim As Integer l = Len(s)
For i As Integer = start To l
If Asc(Mid(s, i, 1)) >= Asc("1") And Asc(Mid(s, i, 1)) <= Asc("9") Then
For j As Integer =i+1 To l+1
If j>l Then
For k As Integer = j-1-paso To i Step -paso
s = Mid(s, 1, k) + sep + Mid(s, k+1, l-k+1)
l = Len(s)
Next k
Exit For
Else
If (Asc(Mid(s, j, 1)) < Asc("0") Or Asc(Mid(s, j, 1)) > Asc("9")) Then
For k As Integer = j-1-paso To i Step -paso
s = Mid(s, 1, k) + sep + Mid(s, k+1, l-k+1)
l = Len(s)
Next k
Exit For
End If
End If
Next j
Exit For
End If
Next i
Print s
End Sub
 
commatize("pi=3.14159265358979323846264338327950288419716939937510582097494459231"," ",6,5)
commatize("The author has two Z$100000000000000 Zimbabwe notes (100 trillion).",".")
commatize("\'-in Aus$+1411.8millions\'",",")
commatize("===US$0017440 millions=== (in 2000 dollars)")
commatize("123.e8000 is pretty big.")
commatize("The land area of the earth is 57268900(29% of the surface) square miles.")
commatize("Ain't no numbers in this here words, nohow, no way, Jose.")
commatize("James was never known as 0000000007")
commatize("Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.")
commatize(" $-140000±100 millions.")
commatize("6/9/1946 was a good year for some.")
 
Sleep</syntaxhighlight>
{{out}}
<pre>
Similar a las entradas de VBA o Phix.
</pre>
 
 
 
=={{header|FutureBasic}}==
Note: FB throws an error when function parameters are missing, hence the need for placeholders.
<syntaxhighlight lang="futurebasic">
local fn commatize( s as Str255, sep as Str255, start as long, stp as long )
if sep[0] == 0 then sep = ","
if start == 0 then start = 1
if stp == 0 then stp = 3
long i, j, k, l = len$(s)
for i = start to l
if ( asc( mid$( s, i, 1 ) ) >= asc("1") and asc( mid$( s, i, 1) ) <= asc("9") )
for j = i + 1 to l + 1
if ( j > l )
for k = j - 1 - stp to i step -stp
s = mid$( s, 1, k ) + sep + mid$( s, k + 1, l - k + 1 )
l = len$(s)
next k
exit for
else
if ( asc( mid$( s, j, 1 ) ) < asc("0") or asc( mid$( s, j, 1 ) ) > asc("9") )
for k = j - 1 - stp to i step -stp
s = mid$( s, 1, k ) + sep + mid$( s, k + 1, l - k + 1 )
l = len$(s)
next k
exit for
end if
end if
next j
exit for
end if
next i
print s
end fn
 
window 1
 
fn commatize("pi=3.14159265358979323846264338327950288419716939937510582097494459231" , " " , 6, 5 )
fn commatize("The author has two Z$100000000000000 Zimbabwe notes (100 trillion)." , "." , 0, 0 )
fn commatize("\'-in Aus$+1411.8millions\'" , "," , 0, 0 )
fn commatize("===US$0017440 millions=== (in 2000 dollars)" , "" , 0, 0 )
fn commatize("123.e8000 is pretty big." , "" , 0, 0 )
fn commatize("The land area of the earth is 57268900(29% of the surface) square miles." , "" , 0, 0 )
fn commatize("Ain't no numbers in this here words, nohow, no way, Jose." , "" , 0, 0 )
fn commatize("James was never known as 0000000007" , "" , 0, 0 )
fn commatize("Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.", ",", 0, 0 )
fn commatize(" $-140000±100 millions." , "" , 0, 0 )
fn commatize("6/9/1946 was a good year for some." , "" , 0, 0 )
 
HandleEvents
</syntaxhighlight>
{{output}}
<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).
"-in Aus$+1,411.8millions"
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
$-140,000±100 millions.
6/9/1946 was a good year for some.
</pre>
 
 
 
=={{header|Go}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 381 ⟶ 721:
fmt.Println(commatize(test, 0, 3, ","))
}
}</langsyntaxhighlight>
 
{{out}}
Line 399 ⟶ 739:
$-140,000±100 millions.
6/9/1946 was a good year for some.
</pre>
 
=={{header|Haskell}}==
 
{{Works with|GHC|7.8.3}}
{{Works with|GHC|8.6.5}}
 
<syntaxhighlight lang="haskell">#!/usr/bin/env runhaskell
 
import Control.Monad (forM_)
import Data.Char (isDigit)
import Data.List (intercalate)
import Data.Maybe (fromMaybe)
 
{-
I use the suffix "2" in identifiers in place of the more conventional
prime (single quote character), because Rosetta Code's syntax highlighter
still doesn't handle primes in identifiers correctly.
-}
 
isDigitOrPeriod :: Char -> Bool
isDigitOrPeriod '.' = True
isDigitOrPeriod c = isDigit c
 
chopUp :: Int -> String -> [String]
chopUp _ [] = []
chopUp by str
| by < 1 = [str] -- invalid argument, leave string unchanged
| otherwise = let (pfx, sfx) = splitAt by str
in pfx : chopUp by sfx
 
addSeps :: String -> Char -> Int -> (String -> String) -> String
addSeps str sep by rev =
let (leading, number) = span (== '0') str
number2 = rev $ intercalate [sep] $ chopUp by $ rev number
in leading ++ number2
 
processNumber :: String -> Char -> Int -> String
processNumber str sep by =
let (beforeDecimal, rest) = span isDigit str
(decimal, afterDecimal) = splitAt 1 rest
beforeDecimal2 = addSeps beforeDecimal sep by reverse
afterDecimal2 = addSeps afterDecimal sep by id
in beforeDecimal2 ++ decimal ++ afterDecimal2
 
commatize2 :: String -> Char -> Int -> String
commatize2 [] _ _ = []
commatize2 str sep by =
let (pfx, sfx) = break isDigitOrPeriod str
(number, sfx2) = span isDigitOrPeriod sfx
in pfx ++ processNumber number sep by ++ sfx2
 
commatize :: String -> Maybe Char -> Maybe Int -> String
commatize str sep by = commatize2 str (fromMaybe ',' sep) (fromMaybe 3 by)
 
input :: [(String, Maybe Char, Maybe Int)]
input =
[ ("pi=3.14159265358979323846264338327950288419716939937510582097494459231", Just ' ', Just 5)
, ("The author has two Z$100000000000000 Zimbabwe notes (100 trillion).", Just '.', Nothing)
, ("\"-in Aus$+1411.8millions\"", Nothing, Nothing)
, ("===US$0017440 millions=== (in 2000 dollars)", Nothing, Nothing)
, ("123.e8000 is pretty big.", Nothing, Nothing)
, ("The land area of the earth is 57268900(29% of the surface) square miles.", Nothing, Nothing)
, ("Ain't no numbers in this here words, nohow, no way, Jose.", Nothing, Nothing)
, ("James was never known as 0000000007", Nothing, Nothing)
, ("Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.", Nothing, Nothing)
, (" $-140000±100 millions.", Nothing, Nothing)
, ("6/9/1946 was a good year for some.", Nothing, Nothing)
]
 
main :: IO ()
main =
forM_ input $ \(str, by, sep) -> do
putStrLn str
putStrLn $ commatize str by sep
putStrLn ""</syntaxhighlight>
{{out}}
<pre>
pi=3.14159265358979323846264338327950288419716939937510582097494459231
pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
 
The author has two Z$100000000000000 Zimbabwe notes (100 trillion).
The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
 
"-in Aus$+1411.8millions"
"-in Aus$+1,411.8millions"
 
===US$0017440 millions=== (in 2000 dollars)
===US$0017,440 millions=== (in 2000 dollars)
 
123.e8000 is pretty big.
123.e8000 is pretty big.
 
The land area of the earth is 57268900(29% of the surface) square miles.
The land area of the earth is 57,268,900(29% of the surface) square miles.
 
Ain't no numbers in this here words, nohow, no way, Jose.
Ain't no numbers in this here words, nohow, no way, Jose.
 
James was never known as 0000000007
James was never known as 0000000007
 
Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
 
$-140000±100 millions.
$-140,000±100 millions.
 
6/9/1946 was a good year for some.
6/9/1946 was a good year for some.
 
</pre>
 
Line 404 ⟶ 855:
These rules are relatively baroque, which demands long names and minimally complex statements, thus:
 
<langsyntaxhighlight Jlang="j">require'regex'
commatize=:3 :0"1 L:1 0
(i.0) commatize y
Line 424 ⟶ 875:
fixed=. numb,;delim&,each (-period)<\ (#numb)}.number
prefix,(start{.text),fixed,(start+len)}.text
)</langsyntaxhighlight>
 
In use, this might look like:
 
<langsyntaxhighlight Jlang="j"> (5;5;' ') commatize 'pi=3.14159265358979323846264338327950288419716939937510582097494459231'
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).'
Line 449 ⟶ 900:
$-140,000±100 millions.
commatize '6/9/1946 was a good year for some.'
6/9/1946 was a good year for some.</langsyntaxhighlight>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.io.File;
import java.util.*;
import java.util.regex.*;
Line 491 ⟶ 942:
System.out.println(m.appendTail(result));
}
}</langsyntaxhighlight>
 
<pre>pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
Line 504 ⟶ 955:
$-140,000±100 millions.
6/9/1946 was a good year for some.</pre>
 
=={{header|jq}}==
'''Adapted from [[#Wren|Wren]]'''
{{works with|jq}}
'''Also works with gojq, the Go implementation of jq.'''
<syntaxhighlight lang="jq">
def commatize($s; $start; $step; $sep):
 
def isExponent($c): "eEdDpP^∙x↑*⁰¹²³⁴⁵⁶⁷⁸⁹" | index($c);
def rev: explode|reverse|implode;
def addSeps($n; $dp):
{ $n, lz: "" }
| if ($dp|not) and ($n|startswith("0")) and $n != "0"
then .k = ($n|sub("^0*";""))
| if (.k == "") then .k = "0" else . end
| .lz = "0" * (($n|length) - (.k|length))
| .n = .k
else .
end
| if $dp
then .n |= rev # reverse if after decimal point
else .
end
| .i = (.n|length) - $step
| until (.i < 1;
.n = .n[: .i] + $sep + .n[.i :]
| .i += - $step )
| if $dp
then .n |= rev # reverse again
else .
end
| .lz + .n;
 
{ acc: $s[:$start],
n: "",
dp: false }
| label $out
| foreach (range($start; $s|length), null) as $j (.;
if $j == null then .emit = true
else $s[$j:$j+1] as $x
| ($x | explode[0]) as $c
| if ($c >= 48 and $c <= 57)
then .n += $x
| if $j == (($s|length)-1)
then if (.acc != "" and isExponent(.acc[-1:]))
then .acc = $s
else .acc += addSeps(.n; .dp)
end
else .
end
elif .n != ""
then if (.acc != "" and isExponent(.acc[-1:]))
then .acc = $s
| .emit=true | ., break $out
elif $x != "."
then .acc += addSeps(.n; .dp) + $s[$j:]
| .emit=true | ., break $out
else .acc += addSeps(.n; .dp) + $x
| .dp = true
| .n = ""
end
else .acc += $x
end
end )
| select(.emit)
| $s, .acc, ""
;
 
# Input: the string to be commatized
def commatize:
commatize(.; 0; 3; ",");
 
def defaults: [
"\"-in Aus$+1411.8millions\"",
"===US$0017440 millions=== (in 2000 dollars)",
"123.e8000 is pretty big.",
"The land area of the earth is 57268900(29% of the surface) square miles.",
"Ain't no numbers in this here words, nohow, no way, Jose.",
"James was never known as 0000000007",
"Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.",
" $-140000±100 millions.",
"6/9/1946 was a good year for some."
];
 
def exercise:
commatize("123456789.123456789"; 0; 2; "*"),
commatize(".123456789"; 0; 3; "-"),
commatize("57256.1D-4"; 0; 4; "__"),
commatize("pi=3.14159265358979323846264338327950288419716939937510582097494459231"; 0; 5; " "),
commatize("The author has two Z$100000000000000 Zimbabwe notes (100 trillion)."; 0; 3; "."),
 
(defaults[] | commatize) ;
 
exercise
</syntaxhighlight>
{{output}}
Exactly as for [[#Wren|Wren]].
 
=={{header|Julia}}==
{{trans|Perl}}
<syntaxhighlight lang="julia">input = [
["pi=3.14159265358979323846264338327950288419716939937510582097494459231", " ", 5],
[raw"The author has two Z$100000000000000 Zimbabwe notes (100 trillion).", "."],
[raw"-in Aus$+1411.8millions"],
[raw"===US$0017440 millions=== (in 2000 dollars)"],
["123.e8000 is pretty big."],
["The land area of the earth is 57268900(29% of the surface) square miles."],
["Ain\'t no numbers in this here words, nohow, no way, Jose."],
["James was never known as 0000000007"],
["Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe."],
[raw" $-140000±100 millions."],
["6/9/1946 was a good year for some."]]
 
function commatize(tst)
grouping = (length(tst) == 3) ? tst[3] : 3
sep = (length(tst) > 1) ? tst[2] : ","
rmend(s) = replace(s, Regex("$sep\\Z") =>"")
greg = Regex(".{$grouping}")
cins(str) = reverse(rmend(replace(reverse(str), greg => s -> s * sep)))
mat = match(Regex("(?<![eE\\/])([1-9]\\d{$grouping,})"), tst[1])
if mat != nothing
return replace(tst[1], mat.match => cins)
end
return tst[1]
end
 
for tst in input
println(commatize(tst))
end
</syntaxhighlight> {{output}} <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).
-in Aus$+1,411.8millions
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
$-140,000±100 millions.
6/9/1946 was a good year for some.
</pre>
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.4-3
 
val r = Regex("""(\.[0-9]+|[1-9]([0-9]+)?(\.[0-9]+)?)""")
Line 563 ⟶ 1,156:
println(tests[4].commatize(sep = "."))
for (test in tests.drop(5)) println(test.commatize())
}</langsyntaxhighlight>
 
{{out}}
Line 583 ⟶ 1,176:
</pre>
 
=={{header|Perl 6Nim}}==
{{trans|Kotlin}}
<lang perl6>commatize 'pi=3.14159265358979323846264338327950288419716939937510582097494459231', :at(6), :ins(' '), :by(5);
This is a translation of the Kotlin (and Go) algorithm with some modifications.
commatize 'The author has two Z$100000000000000 Zimbabwe notes (100 trillion).', :ins<.>;
 
commatize '-in Aus$+1411.8millions';
<syntaxhighlight lang="nim">import re
commatize '===US$0017440 millions=== (in 2000 dollars)';
import strutils
commatize '123.e8000 is pretty big.';
 
commatize 'The land area of the earth is 57268900(29% of the surface) square miles.';
let r = re"(\.[0-9]+|[1-9]([0-9]+)?(\.[0-9]+)?)"
commatize 'Ain\'t no numbers in this here words, nohow, no way, Jose.';
 
commatize 'James was never known as 0000000007';
#---------------------------------------------------------------------------------------------------
commatize 'Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.';
 
commatize ' $-140000±100 millions.';
proc commatize(str: string; startIndex = 0; period = 3; sep = ","): string =
commatize '6/9/1946 was a good year for some.';
 
result = str
var dp, ip = ""
 
if startIndex notin 0..str.high : return
 
# Extract first number (if any).
let (lowBound, highBound) = str.findBounds(r, startIndex)
if lowBound < 0: return
let match = str[lowBound..highBound]
let splits = match.split('.')
 
# Process integer part.
ip = splits[0]
if ip.len > period:
var inserted = 0
for i in countup(ip.high mod period + 1, ip.high, period):
ip.insert(sep, i + inserted)
inserted += sep.len
 
# Process decimal part.
if '.' in match:
dp = splits[1]
if dp.len > period:
for i in countdown(dp.high div period * period, period, period):
dp.insert(sep, i)
ip &= '.' & dp
 
# Replace the number by its "commatized" version.
result[lowBound..highBound] = ip
 
 
#———————————————————————————————————————————————————————————————————————————————————————————————————
 
const Tests = [
"123456789.123456789",
".123456789",
"57256.1D-4",
"pi=3.14159265358979323846264338327950288419716939937510582097494459231",
"The author has two Z$100000000000000 Zimbabwe notes (100 trillion).",
"-in Aus$+1411.8millions",
"===US$0017440 millions=== (in 2000 dollars)",
"123.e8000 is pretty big.",
"The land area of the earth is 57268900(29% of the surface) square miles.",
"Ain't no numbers in this here words, nohow, no way, Jose.",
"James was never known as 0000000007",
"Arthur Eddington wrote: I believe there are " &
"15747724136275002577605653961181555468044717914527116709366231425076185631031296" &
" protons in the universe.",
" $-140000±100 millions.",
"6/9/1946 was a good year for some."]
 
 
echo Tests[0].commatize(period = 2, sep = "*")
echo Tests[1].commatize(period = 3, sep = "-")
echo Tests[2].commatize(period = 4, sep = "__")
echo Tests[3].commatize(period = 5, sep = " ")
echo Tests[4].commatize(sep = ".")
 
for n in 5..Tests.high:
echo Tests[n].commatize()</syntaxhighlight>
 
sub commatize($s, :$at = 0, :$ins = ',', :$by = 3) {
say "Before: ", $s;
say " After: ", $s.subst:
:continue($at), :1st,
/ <[1..9]> <[0..9]>* /,
*.flip.comb(/<{ ".**1..$by" }>/).join($ins).flip;
}</lang>
{{out}}
<pre>1*23*45*67*89.12*34*56*78*9
<pre>Before: pi=3.14159265358979323846264338327950288419716939937510582097494459231
.123-456-789
After: pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
5__7256.1D-4
Before: The author has two Z$100000000000000 Zimbabwe notes (100 trillion).
pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
After: The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
Before: -in Aus$+1411.8millions
After: -in Aus$+1,411.8millions
Before: ===US$00174400017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
After: ===US$0017,440 millions=== (in 2000 dollars)
The land area of the earth is 57,268,900(29% of the surface) square miles.
Before: 123.e8000 is pretty big.
Ain't no numbers in this here words, nohow, no way, Jose.
After: 123.e8000 is pretty big.
James was never known as 0000000007
Before: The land area of the earth is 57268900(29% of the surface) square miles.
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
After: The land area of the earth is 57,268,900(29% of the surface) square miles.
$-140,000±100 millions.
Before: Ain't no numbers in this here words, nohow, no way, Jose.
6/9/1946 was a good year for some.</pre>
After: Ain't no numbers in this here words, nohow, no way, Jose.
Before: James was never known as 0000000007
After: James was never known as 0000000007
Before: Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.
After: Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
Before: $-140000±100 millions.
After: $-140,000±100 millions.
Before: 6/9/1946 was a good year for some.
After: 6/9/1946 was a good year for some.</pre>
 
=={{header|PhixPerl}}==
Displaying before/after only when changes applied.
<lang Phix>procedure commatize(string s, string sep=",", integer start=1, integer step=3)
<syntaxhighlight lang="perl">@input = (
integer l = length(s)
['pi=3.14159265358979323846264338327950288419716939937510582097494459231', ' ', 5],
for i=start to l do
['The author has two Z$100000000000000 Zimbabwe notes (100 trillion).', '.'],
if find(s[i],"123456789") then
['-in Aus$+1411.8millions'],
for j=i+1 to l+1 do
['===US$0017440 millions=== (in 2000 dollars)'],
if j>l or not find(s[j],"0123456789") then
['123.e8000 is pretty big.'],
for k=j-1-step to i by -step do
['The land area of the earth is 57268900(29% of the surface) square s[k+1miles..k'] = sep,
['Ain\'t no numbers in this here words, nohow, no way, Jose.'],
end for
['James was never known as exit0000000007'],
['Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.'],
end if
[' $-140000±100 end formillions.'],
['5/9/1946 was a good year for exitsome.']
);
end if
end for
printf(1,"%s\n",{s})
end procedure
 
for $i (@input) {
commatize("pi=3.14159265358979323846264338327950288419716939937510582097494459231"," ",6,5)
$old = @$i[0];
commatize("The author has two Z$100000000000000 Zimbabwe notes (100 trillion).",".")
$new = commatize("\"-in Aus@$+1411.8millions\""i);
printf("%s\n%s\n\n", $old, $new) if $old ne $new;
commatize("===US$0017440 millions=== (in 2000 dollars)")
}
commatize("123.e8000 is pretty big.")
 
commatize("The land area of the earth is 57268900(29% of the surface) square miles.")
sub commatize {
commatize("Ain't no numbers in this here words, nohow, no way, Jose.")
my($str,$sep,$by) = @_;
commatize("James was never known as 0000000007")
$sep = ',' unless $sep;
commatize("Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.")
$by = 3 unless $by;
commatize(" $-140000±100 millions.")
 
commatize("6/9/1946 was a good year for some.")</lang>
$str =~ s/ # matching rules:
(?<![eE\/]) # not following these characters
([1-9]\d{$by,}) # leading non-zero digit, minimum number of digits required
/c_ins($1,$by,$sep)/ex; # substitute matched text with subroutine output
return $str;
}
 
sub c_ins {
my($s,$by,$sep) = @_;
($c = reverse $s) =~ s/(.{$by})/$1$sep/g;
$c =~ s/$sep$//;
return reverse $c;
}</syntaxhighlight>
{{out}}
<pre>pi=3.14159265358979323846264338327950288419716939937510582097494459231
pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
 
The author has two Z$100000000000000 Zimbabwe notes (100 trillion).
The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
 
-in Aus$+1411.8millions
-in Aus$+1,411.8millions
 
===US$0017440 millions=== (in 2000 dollars)
===US$0017,440 millions=== (in 2000 dollars)
 
The land area of the earth is 57268900(29% of the surface) square miles.
The land area of the earth is 57,268,900(29% of the surface) square miles.
 
Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
 
$-140000±100 millions.
$-140,000±100 millions.</pre>
 
=={{header|Phix}}==
Note that printf() has comma handling built in, for example sprintf("%,d",1234) yields "1,234".<br>
You can find out how that is done by searching for showcommas in builtins\VM\pprntfN.e or (actually JavaScript) in pwa\p2js.js
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">sep</span><span style="color: #0000FF;">=</span><span style="color: #008000;">","</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">start</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">step</span><span style="color: #0000FF;">=</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">start</span> <span style="color: #008080;">to</span> <span style="color: #000000;">l</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"123456789"</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">l</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">></span><span style="color: #000000;">l</span> <span style="color: #008080;">or</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"0123456789"</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">j</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">-</span><span style="color: #000000;">step</span> <span style="color: #008080;">to</span> <span style="color: #000000;">i</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">step</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">k</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sep</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"pi=3.14159265358979323846264338327950288419716939937510582097494459231"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"The author has two Z$100000000000000 Zimbabwe notes (100 trillion)."</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"."</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"\"-in Aus$+1411.8millions\""</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"===US$0017440 millions=== (in 2000 dollars)"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"123.e8000 is pretty big."</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"The land area of the earth is 57268900(29% of the surface) square miles."</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Ain't no numbers in this here words, nohow, no way, Jose."</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"James was never known as 0000000007"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe."</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">" $-140000±100 millions."</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">commatize</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"6/9/1946 was a good year for some."</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{Out}}
<pre>
Line 673 ⟶ 1,379:
 
=={{header|Python}}==
<syntaxhighlight lang="python">
<lang Python>
import re as RegEx
 
Line 711 ⟶ 1,417:
print ( Commatize( "␢␢␢$-140000±100 millions." ))
print ( Commatize( "6/9/1946 was a good year for some." ))
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
Line 722 ⟶ 1,428:
All tests pass (so it's as good as Perl, I guess).
 
<langsyntaxhighlight lang="racket">#lang racket
(require (only-in srfi/13 [string-reverse gnirts]))
 
Line 796 ⟶ 1,502:
(commatize "6/9/1946 was a good year for some.")
=>"6/9/1946 was a good year for some."))
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>for ('pi=3.14159265358979323846264338327950288419716939937510582097494459231', {:6at, :5by, :ins(' ')}),
('The author has two Z$100000000000000 Zimbabwe notes (100 trillion).', {:ins<.>}),
'-in Aus$+1411.8millions',
'===US$0017440 millions=== (in 2000 dollars)',
'123.e8000 is pretty big.',
'The land area of the earth is 57268900(29% of the surface) square miles.',
'Ain\'t no numbers in this here words, nohow, no way, Jose.',
'James was never known as 0000000007',
'Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.',
' $-140000±100 millions.',
'6/9/1946 was a good year for some.'
{
say "Before: ", .[0];
say " After: ", .[1] ?? .[0].&commatize( |.[1] ) !! .&commatize;
}
sub commatize($s, :$at = 0, :$ins = ',', :$by = 3) {
$s.subst: :continue($at), :1st, / <[1..9]> <[0..9]>* /,
*.flip.comb(/<{ ".**1..$by" }>/).join($ins).flip;
}</syntaxhighlight>
{{out}}
<pre>Before: pi=3.14159265358979323846264338327950288419716939937510582097494459231
After: pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
Before: The author has two Z$100000000000000 Zimbabwe notes (100 trillion).
After: The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
Before: -in Aus$+1411.8millions
After: -in Aus$+1,411.8millions
Before: ===US$0017440 millions=== (in 2000 dollars)
After: ===US$0017,440 millions=== (in 2000 dollars)
Before: 123.e8000 is pretty big.
After: 123.e8000 is pretty big.
Before: The land area of the earth is 57268900(29% of the surface) square miles.
After: The land area of the earth is 57,268,900(29% of the surface) square miles.
Before: Ain't no numbers in this here words, nohow, no way, Jose.
After: Ain't no numbers in this here words, nohow, no way, Jose.
Before: James was never known as 0000000007
After: James was never known as 0000000007
Before: Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.
After: Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
Before: $-140000±100 millions.
After: $-140,000±100 millions.
Before: 6/9/1946 was a good year for some.
After: 6/9/1946 was a good year for some.</pre>
 
=={{header|REXX}}==
The hardest part of the &nbsp; '''comma''' &nbsp; function is to locate where a useable&nbsp; ''usable'' &nbsp; number starts and ends.
<langsyntaxhighlight lang="rexx">/*REXX program addadds commas (or other chars) to a string or a number within a string.*/
@. =
@.1= "pi=3.14159265358979323846264338327950288419716939937510582097494459231"
@.2= "The author has two Z$100000000000000 Zimbabwe notes (100 trillion)."
@.3= "-in Aus$+1411.8millions"
@.4= "===US$0017440 millions=== (in 2000 dollars)"
@.5= "123.e8000 is pretty big."
@.6= "The land area of the earth is 57268900(29% of the surface) square miles."
@.7= "Ain't no numbers in this here words, nohow, no way, Jose."
@.8= "James was never known as 0000000007"
@.9= "Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe."
@.10= " $-140000±100 millions."
@.11= "6/9/1946 was a good year for some."
 
do i=1 while @.i\==''; if i\==1 then say /*process each string*/
say 'before:'@.i /*show the before str*/
if i==1 then say ' after:'comma(@.i,'blank',5,,6) /*p=5, start=6*/
if i==2 then say ' after:'comma(@.i,".") /*comma=decimal point*/
if i>2 then say ' after:'comma(@.i) /*use the defaults. */
end /*j*/
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────COMMA subroutine────────────────────*/
comma: procedure; parse arg _,c,p,t,s /*get number and optional options*/
arg ,cU . /*get an uppercase version of C.*/
c=word(c ',', 1) /*get the commatizing char(s).*/
if cU=='BLANK' then c=' ' /*special case for a "blank" sep.*/
o=word(p 3, 1) /*get the optional period length.*/
p=abs(o) /*get the positive period length.*/
t=word(t 999999999, 1) /*get max# of "commas" to insert.*/
s=word(s 1, 1) /*get optional start position. */
 
if \datatype(p,'W') | \datatype(t,"W") | \datatype(s,'W') |,
t<1 | s<1 | p==0 | arg()>5 then return _ /*invalid options?*/
 
n=_'.9'; #=123456789; k=0 /*define some handy-dandy vars. */
 
if o<0 then do /*using a negative period length.*/
b=verify(_,' ', , s) /*position of 1st blank in string*/
e=length(_) - verify(reverse(_), ' ') + 1 - p
end
else do /*using a positive period length.*/
b=verify(n, #, "M", s) /*position of 1st useable digits.*/
z=max(1, verify(n, #"0.", 'M', s))
e=verify(n, #'0', , max(1, verify(n, #"0.", 'M', s))) - p - 1
end
 
if e>0 & b>0 then do ji=e1 towhile b @.i\==''; by -p while k<t if i\==1 then say /*commatizeprocess theeach digsstring.*/
_=insert(c, _, j)say 'before──►'@.i /*commashow spraythe ──►before #str.*/
if ki==k+1 then say ' after──►'comma(@.i, 'blank', 5, , 6) /* p=5, start=6. /*bump commatizing. */
if i==2 then say ' after──►'comma(@.i, ".") end /*jcomma=decimal point.*/
if i>2 then say ' after──►'comma(@.i) /*use the defaults. */
return _</lang>
end /*j*/
'''output''' when using the internal strings for input:
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
comma: procedure; parse arg x,sep,period,times,start /*obtain true case arguments.*/
arg ,sepU /* " uppercase 2nd arg. */
bla= ' ' /*literal to hold a "blank".*/
sep= word(sep ',', 1) /*define comma (string/char.)*/
if sepU=='BLANK' then sep= bla /*allow the use of 'BLANK'. */
period= word(period 3, 1) /*defined "period" to be used*/
times= word(times 999999999, 1) /*limits # changes to be made*/
start= word(start 1 , 1) /*where to start commatizing.*/
/* [↓] various error tests. */
if \datatype(period, 'W') | , /*test for a whole number. */
\datatype(times , 'W') | , /* " " " " " */
\datatype(start , 'W') | , /* " " " " " */
start <1 | , /*start can't be less then 1.*/
arg() >5 then return x /*# of args can't be > 5. */
/* [↑] some arg is invalid. */
op= period /*save the original period. */
period= abs(period) /*use the absolute value. */
n= x'.9' /*a literal string for end. */
digs= 123456789 /*the legal digits for start.*/
digsz= 1234567890 /* " " " " fin. */
digszp= 1234567890. /* " " " " fin. */
/* [↓] note: no zero in digs*/
if op<0 then do /*Negative? Treat as chars. */
beg= start /*begin at the start. */
L= length(x) /*obtain the length of X. */
fin= L - verify( reverse(x), bla) + 1 /*find the ending of the num.*/
end /* [↑] find number ending. */
else do /*Positive? Treat as numbers*/
beg= verify(n, digs, "M",start) /*find beginning of number. */
v2=max(verify(n, digszp,'M',start),1) /*end of the usable number. */
fin=verify(n, digsz, , v2) -period -1 /*adjust the ending (fin). */
end /* [↑] find ending of number*/
#= 0 /*the count of changes made. */
if beg>0 & fin>0 then /* [↓] process TIMES times*/
do j=fin to beg by -period while #<times
x= insert(sep, x, j) /*insert a comma into string.*/
#= # + 1 /*bump the count of changes. */
end /*j*/ /*(maybe no changes are made)*/
return x /*return the commatized str. */</syntaxhighlight>
{{out|output|text=&nbsp; when using the internal default inputs:}}
<pre>
before──►pi=3.14159265358979323846264338327950288419716939937510582097494459231
Line 889 ⟶ 1,651:
=={{header|Scala}}==
===Java-ish version===
<langsyntaxhighlight Scalalang="scala">import java.io.File
import java.util.Scanner
import java.util.regex.Pattern
Line 915 ⟶ 1,677:
val sc = new Scanner(new File("input.txt"))
while (sc.hasNext) commatize(sc.nextLine)
}</langsyntaxhighlight>
 
=={{header|Swift}}==
 
{{trans|Kotlin}}
 
<syntaxhighlight lang="swift">import Foundation
 
extension String {
private static let commaReg = try! NSRegularExpression(pattern: "(\\.[0-9]+|[1-9]([0-9]+)?(\\.[0-9]+)?)")
 
public func commatize(start: Int = 0, period: Int = 3, separator: String = ",") -> String {
guard separator != "" else {
return self
}
 
let sep = Array(separator)
let startIdx = index(startIndex, offsetBy: start)
let matches = String.commaReg.matches(in: self, range: NSRange(startIdx..., in: self))
 
guard !matches.isEmpty else {
return self
}
 
let fullMatch = String(self[Range(matches.first!.range(at: 0), in: self)!])
let splits = fullMatch.components(separatedBy: ".")
var ip = splits[0]
 
if ip.count > period {
var builder = Array(ip.reversed())
 
for i in stride(from: (ip.count - 1) / period * period, through: period, by: -period) {
builder.insert(contentsOf: sep, at: i)
}
 
ip = String(builder.reversed())
}
 
if fullMatch.contains(".") {
var dp = splits[1]
 
if dp.count > period {
var builder = Array(dp)
 
for i in stride(from: (dp.count - 1) / period * period, through: period, by: -period) {
builder.insert(contentsOf: sep, at: i)
}
 
dp = String(builder)
}
 
ip += "." + dp
}
 
return String(prefix(start)) + String(dropFirst(start)).replacingOccurrences(of: fullMatch, with: ip)
}
}
 
let tests = [
"123456789.123456789",
".123456789",
"57256.1D-4",
"pi=3.14159265358979323846264338327950288419716939937510582097494459231",
"The author has two Z$100000000000000 Zimbabwe notes (100 trillion).",
"-in Aus$+1411.8millions",
"===US$0017440 millions=== (in 2000 dollars)",
"123.e8000 is pretty big.",
"The land area of the earth is 57268900(29% of the surface) square miles.",
"Ain't no numbers in this here words, nohow, no way, Jose.",
"James was never known as 0000000007",
"Arthur Eddington wrote: I believe there are " +
"15747724136275002577605653961181555468044717914527116709366231425076185631031296" +
" protons in the universe.",
" $-140000±100 millions.",
"6/9/1946 was a good year for some."
]
 
print(tests[0].commatize(period: 2, separator: "*"))
print(tests[1].commatize(period: 3, separator: "-"))
print(tests[2].commatize(period: 4, separator: "__"))
print(tests[3].commatize(period: 5, separator: " "))
print(tests[4].commatize(separator: "."))
 
for testCase in tests.dropFirst(5) {
print(testCase.commatize())
}</syntaxhighlight>
 
{{out}}
 
<pre>1*23*45*67*89.12*34*56*78*9
.123-456-789
5__7256.1D-4
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).
-in Aus$+1,411.8millions
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
$-140,000±100 millions.
6/9/1946 was a good year for some.</pre>
 
=={{header|VBA}}==
{{trans|Phix}}
<syntaxhighlight lang="vb">Public Sub commatize(s As String, Optional sep As String = ",", Optional start As Integer = 1, Optional step As Integer = 3)
Dim l As Integer: l = Len(s)
For i = start To l
If Asc(Mid(s, i, 1)) >= Asc("1") And Asc(Mid(s, i, 1)) <= Asc("9") Then
For j = i + 1 To l + 1
If j > l Then
For k = j - 1 - step To i Step -step
s = Mid(s, 1, k) & sep & Mid(s, k + 1, l - k + 1)
l = Len(s)
Next k
Exit For
Else
If (Asc(Mid(s, j, 1)) < Asc("0") Or Asc(Mid(s, j, 1)) > Asc("9")) Then
For k = j - 1 - step To i Step -step
s = Mid(s, 1, k) & sep & Mid(s, k + 1, l - k + 1)
l = Len(s)
Next k
Exit For
End If
End If
Next j
Exit For
End If
Next i
Debug.Print s
End Sub
Public Sub main()
commatize "pi=3.14159265358979323846264338327950288419716939937510582097494459231", " ", 6, 5
commatize "The author has two Z$100000000000000 Zimbabwe notes (100 trillion).", "."
commatize """-in Aus$+1411.8millions"""
commatize "===US$0017440 millions=== (in 2000 dollars)"
commatize "123.e8000 is pretty big."
commatize "The land area of the earth is 57268900(29% of the surface) square miles."
commatize "Ain't no numbers in this here words, nohow, no way, Jose."
commatize "James was never known as 0000000007"
commatize "Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe."
commatize " $-140000±100 millions."
commatize "6/9/1946 was a good year for some."
End Sub</syntaxhighlight>{{out}}
<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).
"-in Aus$+1,411.8millions"
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
$-140,000±100 millions.
6/9/1946 was a good year for some.</pre>
 
=={{header|VBScript}}==
Adapted from the Future Basic code
<syntaxhighlight lang="vb">
function commatize( s , sep, start , stp )
if sep ="" then sep = ","
if start ="" then start = 1
if stp ="" then stp = 3
Dim i, j, k, l
l = len(s)
for i = start to l
if ( asc( mid( s, i, 1 ) ) >= asc("1") and asc( mid( s, i, 1) ) <= asc("9") ) then
for j = i + 1 to l + 1
if ( j > l ) then
for k = j - 1 - stp to i step -stp
s = mid( s, 1, k ) + sep + mid( s, k + 1, l - k + 1 )
l = len(s)
next 'k
exit for
else
if ( asc( mid( s, j, 1 ) ) < asc("0") or asc( mid( s, j, 1 ) ) > asc("9") ) then
for k = j - 1 - stp to i step -stp
s = mid( s, 1, k ) + sep + mid( s, k + 1, l - k + 1 )
l = len(s)
Next ' k
exit for
end if
end if
next 'j
exit for
end if
next '
commatize=S
end function
 
wscript.echo commatize("pi=3.14159265358979323846264338327950288419716939937510582097494459231" , " " , 6, 5 )
wscript.echo commatize("The author has two Z$100000000000000 Zimbabwe notes (100 trillion)." , "." , "", "" )
wscript.echo commatize("\'-in Aus$+1411.8millions\'" , "," , "", "" )
wscript.echo commatize("===US$0017440 millions=== (in 2000 dollars)" , "" , "", "" )
wscript.echo commatize("123.e8000 is pretty big." , "" , "", "" )
wscript.echo commatize("The land area of the earth is 57268900(29% of the surface) square miles." , "" , "", "" )
wscript.echo commatize("Ain't no numbers in this here words, nohow, no way, Jose." , "" , "", "" )
wscript.echo commatize("James was never known as 0000000007" , "" , "", "" )
wscript.echo commatize("Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.", ",", "", "" )
wscript.echo commatize(" $-140000±100 millions." , "" , "", "" )
wscript.echo commatize("6/9/1946 was a good year for some." , "" , "", "" )
</syntaxhighlight>
{{out}}
<small>
<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).
\'-in Aus$+1,411.8millions\'
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
$-140,000±100 millions.
6/9/1946 was a good year for some.
</pre>
</small>
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">var commatize = Fn.new { |s, start, step, sep|
var addSeps = Fn.new { |n, dp|
var lz = ""
if (!dp && n.startsWith("0") && n != "0") {
var k = n.trimStart("0")
if (k == "") k = "0"
lz = "0" * (n.count - k.count)
n = k
}
if (dp) n = n[-1..0] // invert if after decimal point
var i = n.count - step
while (i >= 1) {
n = n[0...i] + sep + n[i..-1]
i = i - step
}
if (dp) n = n[-1..0] // invert back
return lz + n
}
 
var t = s.toList
var isExponent = Fn.new { |c| "eEdDpP^∙x↑*⁰¹²³⁴⁵⁶⁷⁸⁹".contains(c) }
var acc = (start == 0) ? "" : t.toList[0...start].join()
var n = ""
var dp = false
for (j in start...t.count) {
var c = t[j].codePoints[0]
if (c >= 48 && c <= 57) {
n = n + t[j]
if (j == t.count-1) {
if (acc != "" && isExponent.call(acc[-1])) {
acc = s
} else {
acc = acc + addSeps.call(n, dp)
}
}
} else if (n != "") {
if (acc != "" && isExponent.call(acc[-1])) {
acc = s
break
} else if (t[j] != ".") {
acc = acc + addSeps.call(n, dp) + t[j..-1].join()
break
} else {
acc = acc + addSeps.call(n, dp) + t[j]
dp = true
n = ""
}
} else {
acc = acc + t[j]
}
}
 
System.print(s)
System.print(acc)
System.print()
}
 
// special version of the above which uses defaults for start, step and sep.
var commatize2 = Fn.new { |s| commatize.call(s, 0, 3, ",") }
 
commatize.call("123456789.123456789", 0, 2, "*")
commatize.call(".123456789", 0, 3, "-")
commatize.call("57256.1D-4", 0, 4, "__")
commatize.call("pi=3.14159265358979323846264338327950288419716939937510582097494459231", 0, 5, " ")
commatize.call("The author has two Z$100000000000000 Zimbabwe notes (100 trillion).", 0, 3, ".")
 
var defaults = [
"\"-in Aus$+1411.8millions\"",
"===US$0017440 millions=== (in 2000 dollars)",
"123.e8000 is pretty big.",
"The land area of the earth is 57268900(29\% of the surface) square miles.",
"Ain't no numbers in this here words, nohow, no way, Jose.",
"James was never known as 0000000007",
"Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.",
" $-140000±100 millions.",
"6/9/1946 was a good year for some."
]
 
defaults.each { |d| commatize2.call(d) }</syntaxhighlight>
 
{{out}}
<pre>
123456789.123456789
1*23*45*67*89.12*34*56*78*9
 
.123456789
.123-456-789
 
57256.1D-4
5__7256.1D-4
 
pi=3.14159265358979323846264338327950288419716939937510582097494459231
pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
 
The author has two Z$100000000000000 Zimbabwe notes (100 trillion).
The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
 
"-in Aus$+1411.8millions"
"-in Aus$+1,411.8millions"
 
===US$0017440 millions=== (in 2000 dollars)
===US$0017,440 millions=== (in 2000 dollars)
 
123.e8000 is pretty big.
123.e8000 is pretty big.
 
The land area of the earth is 57268900(29% of the surface) square miles.
The land area of the earth is 57,268,900(29% of the surface) square miles.
 
Ain't no numbers in this here words, nohow, no way, Jose.
Ain't no numbers in this here words, nohow, no way, Jose.
 
James was never known as 0000000007
James was never known as 0000000007
 
Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
 
$-140000±100 millions.
$-140,000±100 millions.
 
6/9/1946 was a good year for some.
6/9/1946 was a good year for some.
 
</pre>
PureFox
9,482

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/245752...352436"