Rosetta Code

Number names: Difference between revisions

Page Discussion

Number names (view source)

Revision as of 20:17, 25 March 2010

2,976 bytes removed ,  14 years ago
→‎{{header|Fortran}}
(Added Fortran)
Line 624:
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<lang fortran>program test_spellspell
 
implicit none
integer :: iose
integer :: numi
integer :: m
character (9), dimension (0 : 19), parameter :: small = (/' ', &
integer :: n
& 'one ', &
character (9), dimension (19), parameter :: small = &
& 'two ', &
& (/'one ', 'two ', 'three ', 'four & 'three ', &
& 'five ', 'six ', 'seven & ', 'four eight ', &
& 'nine ', 'ten ', 'eleven & ', 'five twelve ', &
& 'thirteen ', 'fourteen ', 'fifteen ', 'sixteen ', &
& 'six ', &
& 'seventeen', 'eighteen ', 'nineteen '/)
& 'seven ', &
character (7), dimension (2 : 9), parameter :: tens = &
& 'eight ', &
& (/'twenty ', 'thirty ', 'forty ', 'fifty & ', 'nine sixty ', &
& 'seventy', 'eighty ', 'ninety '/)
& 'ten ', &
character (8), dimension (3), parameter :: big = &
& 'eleven ', &
& (/'thousand', 'million ', 'billion '/)
& 'twelve ', &
character (256) :: r
& 'thirteen ', &
& 'fourteen ', &
& 'fifteen ', &
& 'sixteen ', &
& 'seventeen', &
& 'eighteen ', &
& 'nineteen '/)
character (7), dimension (2 : 9), parameter :: tens = (/'twenty ', &
& 'thirty ', &
& 'forty ', &
& 'fifty ', &
& 'sixty ', &
& 'seventy', &
& 'eighty ', &
& 'ninety '/)
character (8), dimension (0 : 3), parameter :: big = (/' ', &
& 'thousand', &
& 'million ', &
& 'billion '/)
 
! Read integral numbers from standard input.
! Spell the numbers on standard output.
do
read (*, *, iostat = iosi) numn
if (iosi /= 0) then
exit
end if
writeif (*,n '(a)'== 0) trim (spell (num))then
r = 'zero'
end do
 
contains
 
!-------------------------------------------------------------------------------
 
function spell_99 (num) result (res)
! Helper function for spell_999.
! Spells integer num, where num must be between 0 and 99 inclusive.
 
implicit none
integer, intent (in) :: num
character (256) :: res
integer :: num_div_10
integer :: num_mod_10
 
if (num < 20) then
res = small (num)
else
num_div_10r = num / 10''
num_mod_10m = numabs - 10 * num_div_10(n)
rese = tens (num_div_10)0
if (num_mod_10 > 0) then
res = trim (res) // '-' // small (num_mod_10)
end if
end if
 
end function spell_99
 
!-------------------------------------------------------------------------------
 
function spell_999 (num) result (res)
! Helper function for spell.
! Spells integer num, where num must be between 0 and 999 inclusive.
 
implicit none
integer, intent (in) :: num
character (256) :: res
integer :: num_div_100
integer :: num_mod_100
 
num_div_100 = num / 100
num_mod_100 = num - 100 * num_div_100
res = spell_99 (num_mod_100)
if (num_div_100 > 0) then
res = trim (small (num_div_100)) // ' hundred ' // res
end if
 
end function spell_999
 
!-------------------------------------------------------------------------------
 
function spell (num) result (res)
! Spells integer num, whose range is machine dependent.
 
implicit none
integer, intent (in) :: num
character (256) :: res
integer :: abs_num
integer :: abs_num_div_1000
integer :: abs_num_mod_1000
integer :: ex ! exponent of 1000
 
if (num == 0) then
res = 'zero'
else
res = ''
abs_num = abs (num)
ex = 0
do
abs_num_div_1000if =(m abs_num== /0) 1000then
abs_num_mod_1000 = abs_num - 1000 * abs_num_div_1000
if (abs_num_mod_1000 > 0) then
res = trim (spell_999 (abs_num_mod_1000)) // ' ' // trim (big (ex)) // ' ' // res
end if
if (abs_num_div_1000 == 0) then
exit
end if
abs_numif =(modulo abs_num_div_1000(m, 1000) > 0) then
ex = exif +(e 1> 0) then
r = trim (big (e)) // ' ' // r
end if
if (modulo (m, 100) > 0) then
if (modulo (m, 100) < 20) then
r = trim (small (modulo (m, 100))) // ' ' // r
else
if (modulo (m, 10) > 0) then
r = trim (small (modulo (m, 10))) // ' ' // r
r = trim (tens (modulo (m, 100) / 10)) // '-' // r
else
r = trim (tens (modulo (m, 100) / 10)) // ' ' // r
end if
end if
end if
if (modulo (m, 1000) / 100 > 0) then
r = 'hundred' // ' ' // r
r = trim (small (modulo (m, 1000) / 100)) // ' ' // r
end if
end if
m = m / 1000
e = e + 1
end do
if (numn < 0) then
resr = 'negative' // ' ' // resr
end if
end if
write (*, '(a)') trim (r)
end do
 
end functionprogram spell</lang>
 
end program test_spell</lang>
Sample input:
<lang>-1
Line 771 ⟶ 703:
forty-two
two billion one hundred forty-seven million four hundred eighty-three thousand six hundred forty-seven</lang>
 
=={{header|Haskell}}==
<lang haskell>import Data.List (intercalate, unfoldr)
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/84003"