Shell Programming and Scripting

Good solution.

Greetings from the void,

I am sed-centric, so here is a sed solution provided in an example form. I may ramble on a bit, but better than to starve for details.

The script creates a sequence of numbers from 1 to 15 digits, which are printed to the screen after they are formatted with commas.

The sed statement has an indirect logic. I'll try to explain.

The first pair of slashes test for a string having the minimum of characters required to place a comma (section1). The indirect part is that only select characters on the end of the string are tested, and there can be more characters preceding the tested portion, but is not required for the test.

The (2nd section) begins with s/ and has 2 match tests contained within the brackets,
like \( match_exp1 \) and the next \( match_exp2 \). Essentially this just splits the string so that the comma is placed correctly.
The next slash divides this section from the substitution section.

The (3rd section) reassembles the matched text, which is marked by the labels \1 and \2 which correspond to the matched text from the brackets in the preceding section 2. In between the labels is the comma needed for the formatting.

Each successive sed test/substitute statement, looks for commas added by the preceding sed substitute section. The code has a continue on (failed sed match) approach, where the number string gets passed thru if no matches are found. Essentially it will not add unneeded commas, but will retain any that were added in prior sed substitution sections.

Note that the semicolons in the sed statement are like seperate sed statements, but they are combined into a single pass, instead of using seperate sed invocations. I like to break my complex seds down to seperate lines because its easier to visualize/debug, and it runs just fine in this format.

Note that this code only works on integers, but it indubitably could be tweaked to handle decimal values. I would just parse the decimal and right of decimal into a variable, run this code on the remainder, which is then an integer, then reassemble the two parts for a comma formatted decimal number.

From the code below, with sections numbered:

Code:

 sed '/....$/ s/^\(.*\)\(...\)$/\1,\2/;
      1-----   2-------------- 3-----

The bash script follows:

Code:

#!/bin/sh
#
# testTube1.sh
#
# ### Notes ###
#
# The parser is limited to a number no greater than 1 x 10^15 digits.
# This is greater than the Tera range; in the Peta range.
# The range can easily be expanded - the sed pattern below is easy to mod.
# Power / 3 = number of commas needed. This script provides for 5 commas.
#
# m Mega 1 x 10^6
# g Giga 1 x 10^9
# t Tera 1 x 10^12
# p Peta 1 x 10^15
#
# 1 x 10^15 =     1,000,000,000,000,000
# 1 x 10^18 = 1,000,000,000,000,000,000
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

# void before use
rawnum=

# make a sequence of numbers that increase exponentially in base 10
# aka { 5, 55, 555, 5555, etc... }
#
for i in `seq 1 18`
do

  # grow a number exponentially
  rawnum="${rawnum}5"

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# run the number thru the comma mill
#
echo $rawnum \
| sed '/....$/ s/^\(.*\)\(...\)$/\1,\2/;
/....,...$/ s/^\(.*\)\(...,...\)$/\1,\2/;
/....,...,...$/ s/^\(.*\)\(...,...,...\)$/\1,\2/;
/....,...,...,...$/ s/^\(.*\)\(...,...,...,...\)$/\1,\2/;
/....,...,...,...,...$/ s/^\(.*\)\(...,...,...,...,...\)$/\1,\2/'
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

done
# # #
# EOF
#