Shell Programming and Scripting

#!/bin/bash
# numalpha.sh
alpha=""
n=1
numalpha()
{
	if [ $n -eq 1 ]
	then
		alpha="first"
	fi
	if [ $n -eq 2 ]
	then
		alpha="second"
	fi
	if [ $n -eq 3 ]
	then
		alpha="third"
	fi
	if [ $n -eq 4 ]
	then
		alpha="fourth"
	fi
	# And so on...
}
# Test for integers numbers only.
for n in {1..4}
do
	numalpha
	echo "$n = $alpha"
done

Last login: Sat Feb 14 21:06:21 on ttys000
AMIGA:barrywalker~> cd Desktop/Code/Shell
AMIGA:barrywalker~/Desktop/Code/Shell> chmod 755 numalpha.sh
AMIGA:barrywalker~/Desktop/Code/Shell> ./numalpha.sh
1 = first
2 = second
3 = third
4 = fourth
AMIGA:barrywalker~/Desktop/Code/Shell> _

$ nblexical=("zero" "first" "second" "third")
$ nb=2
$ echo ${nblexical[$nb]} 
second

#!/bin/bash
# numalpha.sh
alpha=""
numalpha()
{
	if [ $1 -eq 1 ]
	then
		alpha="first"
	fi
	if [ $1 -eq 2 ]
	then
		alpha="second"
	fi
	if [ $1 -eq 3 ]
	then
		alpha="third"
	fi
	if [ $1 -eq 4 ]
	then
		alpha="fourth"
	fi
	# And so on...
}
# Test for integer numbers only.
text=( This is the 1 and only attempt to change the 4 word inside this string. )
count=0
while [ $count -lt ${#text[@]} ]
do
	if [[ ${text[$count]} =~ ^-?[0-9]+$ ]]
	then
		numalpha "${text[$count]}"
		printf "$alpha "
		count=$((count+1))
	fi
	printf "${text[$count]} "
	alpha=""
	count=$((count+1))
done

Last login: Sat Feb 14 22:54:01 on ttys000
AMIGA:barrywalker~> cd Desktop/Code/Shell
AMIGA:barrywalker~/Desktop/Code/Shell> ./numalpha.sh
This is the first and only attempt to change the fourth word inside this string.
AMIGA:barrywalker~/Desktop/Code/Shell> _

#!/bin/ksh
awk '
BEGIN {	# Initialize variables...
	# Final single digits:
	fd[0] = "zeroth"; fd[1] = "first"; fd[2] = "second"; fd[3] = "third"
	fd[4] = "fourth"; fd[5] = "fifth"; fd[6] = "sixth"; fd[7] = "seventh"
	fd[8] = "eighth"; fd[9] = "ninth"
	# Leading single digits:
	ld[1] = "one"; ld[2] = "two"; ld[3] = "three"; ld[4] = "four"
	ld[5] = "five"; ld[6] = "six"; ld[7] = "seven"; ld[8] = "eight"
	ld[9] = "nine"
	# Final teens:
	ft[10] = "tenth"; ft[11] = "eleventh"; ft[12] = "twelfth"
	ft[13] = "thirteenth"; ft[14] = "fourteenth"; ft[15] = "fifteenth"
	ft[16] = "sixteenth"; ft[17] = "seventeenth"; ft[18] = "eighteenth"
	ft[19] = "nineteenth"
	# Leading teens:
	lt[10] = "ten"; lt[11] = "eleven"; lt[12] = "twelve"
	lt[13] = "thirteen"; lt[14] = "fourteen"; lt[15] = "fifteen"
	lt[16] = "sixteen"; lt[17] = "seventeen"; lt[18] = "eighteen"
	lt[19] = "nineteen"
	# Final tens:
	fT[2] = "twentieth"; fT[3] = "thirtieth"; fT[4] = "fortieth"
	fT[5] = "fiftieth"; fT[6] = "sixtieth"; fT[7] - "seventieth"
	fT[8] = "eightieth"; fT[9] = "ninetieth"
	# Leading tens:
	lT[2] = "twenty"; lT[3] = "thirty"; lT[4] = "forty"; lT[5] = "fifty"
	lT[6] = "sixty"; lT[7] = "seventy"; lT[8] = "eighty"; lT[9] = "ninety"
	# Units:
	u[2] = "thousand"; u[3] = "million"; u[4] = "billion"; u[5] = "trillion"
	u[6] = "quadrillion"; u[7] = "quintillion"; u[8] = "sextillion"
	u[9] = "septillion"; u[10] = "octillion"; u[11] = "nonillion"
	u[12] = "decillion"; u[13] = "undecillion"
	# The last entry above will only be used in overflow diagnostics.  If
	# more entries are added, remember that one extra entry must be added.
	# The following maximum u[] subscript must be updated if more entries
	# are added above.
	ucnt = 13
}
# Function to print US English string corresponding to 3 digit numeric string.
function p3(units, gcnt, gnum,    d1, d2, d3, d23) {
	# If we have a zero and this is not the last group, nothing to print...
	if(g[gnum] == 0 && gnum < gcnt) return(1)
	# Grab inividual digits and last two digits...
	d1 = int(g[gnum] / 100)
	d23 = g[gnum] % 100
	d2 = int(d23 / 10)
	d3 = d23 % 10
	# Hundreds to print?
	if(d1)
		printf("%s hundred%s", ld[d1],
			d23 ? " " : (gcnt == gnum) ? "th\n" : " " units \
				(t[gnum] ? " " : "th\n"))
	# Print last two digits...
	if(d23 || (d1 == 0 && gnum == gcnt))
		if(d2 == 1) 
			# 10-19:
			printf("%s", (gnum == gcnt) ? ft[d23] "\n" : \
				lt[d23] " " units (t[gnum] ? " " : "th\n"))
		else if(d2)
			# 20-99:
			if(d3)	# [2-9][1-9]:
				printf("%s-%s", lT[d2],
					(gnum == gcnt) ? fd[d3] "\n" : \
					ld[d3] " " units \
					(t[gnum] ? " " : "th\n"))
			else	# [2-9]0:
				printf("%s", (gnum == gcnt) ? fT[d2] "\n" : \
					lT[d2] " " units \
					(t[gnum] ? " " : "th\n"))
		else	# 0-9:
			printf("%s", (gnum == gcnt) ? fd[d3] "\n" : ld[d3] " " \
				units (t[gnum] ? " " : "th\n"))
	return(t[gnum])
}
# Process the first field from each line in an input file...
{	# Show original input...
	printf("Input:\"%s\"\n", $0)
	# Check for non-digits
	if(match($1, /[^[:digit:]]/)) {
		print "Only digits are alloweed."
		next
	}
	# Strip leading 0s
	if(match($1, /^0+/)) {
		$1 = (RLENGTH == length($1)) ? "0" : substr($1, RLENGTH + 1)
		printf("Updated input:\"%s\"\n", $0)
	}
	# Split into groups of three digits...
	ng = int((length($1) + 2) / 3)
	if(ng == 0) next	# skip eimpty lines
	if(ng >= ucnt) {	# Too big to handle?
		printf("Can only handle numbers less than one %s.\n",
			u[ucnt])
		next
	}
	gw = length($1) - (ng - 1) * 3
	off = 1
	for(i = 1; i <= ng; i++) {
		g[i] = substr($1, off, gw)
		t[i] = substr($1, off + gw) + 0
		off += gw
		gw = 3
	}
	# Process the groups of digits...
	for(i = 1; p3(u[ng + 1 - i], ng, i); i++);
}' file

0
1
11
111
123000000456000000789
1000000000000000000000023
2034500
975310000000000000000000000987654321
1000000000000000000000000000000000000

Input:"0"
Updated input:"0"
zeroth
Input:"1"
first
Input:"11"
eleventh
Input:"111"
one hundred eleventh
Input:"123000000456000000789"
one hundred twenty-three quintillion four hundred fifty-six billion seven hundred eighty-ninth
Input:"1000000000000000000000023"
one septillion twenty-third
Input:"2034500"
two million thirty-four thousand five hundredth
Input:"975310000000000000000000000987654321"
nine hundred seventy-five decillion three hundred ten nonillion nine hundred eighty-seven million six hundred fifty-four thousand three hundred twenty-first
Input:"1000000000000000000000000000000000000"
Can only handle numbers less than one undecillion.

0
1
11
111
1,011
1_012
123000000456000000789
1000000000000000000000023
2034500
975310000000000000000000000987654321
1000000000000000000000000000000000000

perl -M"Lingua::EN::Numbers qw(num2en num2en_ordinal)" -n -e 'chomp;
print " Cardinal for $_: ",num2en($_),"\n";
print " Ordinal  for $_: ", num2en_ordinal($_),"\n";' data2

 Cardinal for 0: zero
 Ordinal  for 0: zeroth
 Cardinal for 1: one
 Ordinal  for 1: first
 Cardinal for 11: eleven
 Ordinal  for 11: eleventh
 Cardinal for 111: one hundred and eleven
 Ordinal  for 111: one hundred and eleventh
 Cardinal for 1,011: one thousand and eleven
 Ordinal  for 1,011: one thousand and eleventh
 Cardinal for 1_012: 
 Ordinal  for 1_012: 
 Cardinal for 123000000456000000789: one hundred and twenty-three quintillion, four hundred and fifty-six billion, seven hundred and eighty-nine
 Ordinal  for 123000000456000000789: one hundred and twenty-three quintillion, four hundred and fifty-six billion, seven hundred and eighty-ninth
 Cardinal for 1000000000000000000000023: one septillion and twenty-three
 Ordinal  for 1000000000000000000000023: one septillion and twenty-third
 Cardinal for 2034500: two million, thirty-four thousand, five hundred
 Ordinal  for 2034500: two million, thirty-four thousand, five hundredth
 Cardinal for 975310000000000000000000000987654321: nine hundred and seventy-five times ten to the thirty-third, three hundred and ten nonillion, nine hundred and eighty-seven million, six hundred and fifty-four thousand, three hundred and twenty-one
 Ordinal  for 975310000000000000000000000987654321: nine hundred and seventy-five times ten to the thirty-third, three hundred and ten nonillion, nine hundred and eighty-seven million, six hundred and fifty-four thousand, three hundred and twenty-first
 Cardinal for 1000000000000000000000000000000000000: one times ten to the thirty-sixth
 Ordinal  for 1000000000000000000000000000000000000: one times ten to the thirty-sixthth