Problem Statement

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.

Write a function that takes a string as an argument with optional arguments or parameters (the format of parameters/options is left to the programmer) that in general, adds commas (or some other characters, including blanks or tabs) to the first numeric part of a string (if it's suitable for commatizing as per the rules below), and returns that newly commatized string. Some of the commatizing rules (specified below) are arbitrary, but they'll be a part of this task requirements, if only to make the results consistent amongst national preferences and other disciplines. The number may be part of a larger (non-numeric) string such as:

The string may possibly not have a number suitable for commatizing, so it should be untouched and no error generated. If any argument (option) is invalid, nothing is changed and no error need be generated (quiet execution, no fail execution).   Error message generation is optional. The exponent part of a number is never commatized.   The following string isn't suitable for commatizing:   9.7e+12000 Leading zeroes are never commatized.   The string   0000000005714.882   after commatization is:   0000000005,714.882 Any   period   (.)   in a number is assumed to be a   decimal point. The original string is never changed   except   by the addition of commas   [or whatever character(s) is/are used for insertion], if at all. To wit, the following should be preserved:

Any exponent character(s) should be supported: Numbers may be terminated with any non-digit character, including subscripts and/or superscript:   41421356243   or   7320509076(base 24). The character(s) to be used for the comma can be specified, and may contain blanks, tabs, and other whitespace characters, as well as multiple characters.   The default is the comma (,) character. The   period length   can be specified   (sometimes referred to as "thousands" or "thousands separators").   The   period length   can be defined as the length (or number) of the decimal digits between commas.   The default period length is   3. The location of where to start the scanning for the target field (the numeric part) should be able to be specified.   The default is   1. The character strings below may be placed in a file (and read) or stored as simple strings within the program.

The value of   pi   (expressed in base 10)   should be separated with blanks every   5   places past the decimal point, the Zimbabwe dollar amount should use a decimal point for the "comma" separator: where the penultimate string has three leading blanks   (real blanks are to be used).

Let's start with the solution:

import java.io.File
import java.util.Scanner
import java.util.regex.Pattern

object CommatizingNumbers extends App {

  def commatize(s: String): Unit = commatize(s, 0, 3, ",")

  def commatize(s: String, start: Int, step: Int, ins: String): Unit = {
    if (start >= 0 && start <= s.length && step >= 1 && step <= s.length) {
      val m = Pattern.compile("([1-9][0-9]*)").matcher(s.substring(start))
      val result = new StringBuffer(s.substring(0, start))
      if (m.find) {
        val sb = new StringBuilder(m.group(1)).reverse
        for (i <- step until sb.length by step) sb.insert(i, ins)
        m.appendReplacement(result, sb.reverse.toString)
      }
      println(m.appendTail(result))
    }
  }

  commatize("pi=3.14159265358979323846264338327950288419716939937510582" + "097494459231", 6, 5, " ")
  commatize("The author has two Z$100000000000000 Zimbabwe notes (100 " + "trillion).", 0, 3, ".")

  val sc = new Scanner(new File("input.txt"))
  while (sc.hasNext) commatize(sc.nextLine)
}