Using regex to add leading zeroes

Question

I would like to add a certain number of leading zeroes (say up to 3) to all numbers of a string. For example:

Input: /2009/5/song 01 of 12

Outpu

Answer 1

If your regular expression implementation does not support look-behind and/or look-ahead assertions, you can also use this regular expression:

(^|\D)\d{1,3}(\D|$)

And replace the match with $1 + padLeft($2, 4, "0") + $3 where $1 is the match of the first group and padLeft(str, length, padding) is a function that prefixes str with padding until the length length is reached.

Answer 2

In Perl:

s/([0-9]+)/sprintf('%04d',$1)/ge;

Answer 3

A sample:

>>> re.sub("(?<!\d)0*(\d{1,3})(?!\d)","000\\1","/2009/5/song 01 of 3")
'/2009/0005/song 0001 of 0003'

Note:

• It only works for numbers 1 - 9 for now
• It is not well test yet

I can't think of a single regex without using callbacks for now* (there might be a way to do it).

Here are two regular expression to process that:

>>> x = "1/2009/5/song 01 of 3 10 100 010 120 1200 abcd"
>>>
>>> x = re.sub("(?<!\d)0*(\d{1,3})(?!\d)","000\\1",x)
#'0001/2009/0005/song 0001 of 0003 00010 000100 00010 000120 1200 abcd'
>>>
>>> re.sub("0+(\d{4})(?!\d)","\\1",x) #strip extra leading zeroes
'0001/2009/0005/song 0001 of 0003 0010 0100 0010 0120 1200 abcd'

Answer 4

A valid Scala program to replace all groups of n digits to 4. $$ escapes the line ending char $, because we are using StringContext (string prefixed by s).

  (f/:(1 to 3)){case (res,i) =>
     res.replaceAll(s"""(?<=[^\\d]|^)(\\d$i)(?=[^\\d]|$$)""", "0"*(4-i)+"$1")
  }

Answer 5

^{<warning> This assumes academic interest, of course you should use callbacks to do it clearly and correctly </warning>}

I'm able to abuse regular expressions to have two leading zeros (.NET flavor):

s = Regex.Replace(s, @".(?=\b\d\b)|(?=\b\d{1,2}\b)", "$&0");

It doesn't work if there's a number in the beginning of the string. This works by matching the 0-width before a number or the character before a number, and replacing them with 0.

I had no luck expanding it to three leading zeros, and certainly not more.

Answer 6

Here is a Perl solution without callbacks or recursion. It does use the Perl regex extension of execution of code in lieu of the straight substitution (the e switch) but this is very easily extended to other languages that lack that construct.

#!/usr/bin/perl

while (<DATA>) {
   chomp;
   print "string:\t\t\t$_\n";
# uncomment if you care about 0000000 case:
#   s/(^|[^\d])0+([\d])/\1\2/g;
#   print "now no leading zeros:\t$_\n";    
   s/(^|[^\d]{1,3})([\d]{1,3})($|[^\d]{1,3})/sprintf "%s%04i%s",$1,$i=$2,$3/ge;
   print "up to 3 leading zeros:\t$_\n";
}
print "\n";

__DATA__
/2009/5/song 01 of 12
/2010/10/song 50 of 99
/99/0/song 1 of 1000
1
01
001
0001
/001/
"02"
0000000000

Output:

string:                /2009/5/song 01 of 12
up to 3 leading zeros:  /2009/0005/song 0001 of 0012
string:                /2010/10/song 50 of 99
up to 3 leading zeros:  /2010/0010/song 0050 of 0099
string:                /99/0/song 1 of 1000
up to 3 leading zeros:  /0099/0/song 0001 of 1000
string:                1
up to 3 leading zeros:  0001
string:                01
up to 3 leading zeros:  0001
string:                001
up to 3 leading zeros:  0001
string:                0001
up to 3 leading zeros:  0001
string:                /001/
up to 3 leading zeros:  /0001/
string:                "02"
up to 3 leading zeros:  "0002"
string:                0000000000
up to 3 leading zeros:  0000000000