Number names: Difference between revisions

=={{header|360 Assembly}}==

{{trans|AppleSoft Basic}}

NUMNAME CSECT

USING NUMNAME,R13

PG DS CL256

YREGS

{{out}}

<pre>

 

=={{header|Ada}}==

 

procedure Integers_In_English is

Spell_And_Print(Samples(I));

end loop;

The implementation goes up to 10¹⁸-1

and also supports negative and zero inputs.

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8.8d.fc9.i386]}}

# returns a string representation of n in words. Currently

deals with anything from 0 to 999 999 999. #

OD;

stop iteration:

 

{{out|Example input with output}}

 

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

EXCEPTION value error = ("Value Error", stop);

 

FOR i TO 6 DO prod := prod * 10**i + i; example(prod) OD;

 

{{out}}

<pre>

2010: two thousand and ten

</pre>

 

=={{header|AppleScript}}==

With AppleScript's ability to access some of macOS's Objective-C frameworks, it's possible to get the job done with a single line:

 

use framework "Foundation"

 

 

numberToWords(-3.6028797018963E+10)

 

NSNumberFormatter supports several natural languages and by default uses the one set for the user on the host machine. However, its English is limited to US English, so there are no "and"s in the results.

Both scripts can display strange results with numbers at the extreme limits of floating-point resolution.

 

-- n: AppleScript integer or real.

-- longScale (optional): boolean. Whether to use long-scale -illions instead of short-scale. Default: false

--> "minus three billion six hundred and two thousand eight hundred and seventy-nine million seven hundred and one thousand eight hundred and ninety-six point three four"

numberToEnglish from -3.60287970189634E+12 with milliards

 

=={{header|Applesoft BASIC}}==

Handles zero and negative integers. Rounding errors occur with big numbers.

20 GOSUB 100"NUMBER NAME

30 PRINT R$

288 DATA "EIGHT", "EIGHTEEN", "EIGHTY", "OCTILLION"

289 DATA "NINE", "NINETEEN", "NINETY", "NONILLION"

 

=={{header|AutoHotkey}}==

n =

Random Digits, 1, 36 ; random number with up to 36 digits

PrettyNumber(n) { ; inserts thousands separators into a number string

Return RegExReplace( RegExReplace(n,"^0+(\d)","$1"), "\G\d+?(?=(\d{3})+(?:\D|$))", "$0,")

 

=={{header|AWK}}==

# syntax: GAWK -f NUMBER_NAMES.AWK

BEGIN {

split("ten twenty thirty forty fifty sixty seventy eighty ninety",tens," ")

}

{{out}}

<pre>

=={{header|BASIC}}==

{{works with|QBasic}}

 

'small

 

int2Text$ = RTRIM$(outP)

{{out|Sample outputs}} (including the answer to the ultimate question of life, the universe, and everything):

one

Gimme a number! 0

one billion one

Gimme a number! &h7fffffff

 

=={{header|Batch File}}==

{{trans|BASIC}}

::Batch File Implementation

 

 

set TotalOut=%TotalOut:~0,-1%

{{Out}}

<pre>>NUMBER.BAT

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

test%() = 0, 1, 2, 19, 20, 21, 99, 100, 101, 300, 310, 1001, -1327, 1501, \

\ 10203, 12609, 101104, 102003, 467889, 1005006, -123000789

ENDIF

NEXT i%

{{out}}

<pre>

minus one hundred and twenty-three million, seven hundred and eighty-nine

</pre>

 

=={{header|BlitzMax}}==

{{trans|C++}}

 

 

Framework BRL.StandardIO

Local numberSpell:TSpell = New TSpell

Print number + " " + numberSpell.spell(number)

<pre>

99 ninety-nine

 

=={{header|C}}==

#include <string.h>

 

say_number("123456789012345678901234567890123456789012345678900000001");

return 0;

{{out}}

<pre>minus forty-two

{{works with|C sharp|2.0+, works for numbers between 0 and 999,999,999}}

 

 

class NumberNamer {

}

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <iostream>

using std::string;

SPELL_IT(1234567890);

return 0;

{{out}}

<pre>

{{trans|Common Lisp}}

 

 

=={{header|CoffeeScript}}==

{{trans|Python}}

 

spell_integer = (n) ->

tens = [null, null, "twenty", "thirty", "forty",

console.log spell_integer 2010

console.log spell_integer 4000123007913

 

{{out}}

 

 

20 dim s$(11),ts$(11),t$(11),o$(11):co=39

30 for i=0 to 11:read s$(i),ts$(i),t$(i),o$(i):next

1009 data nine,nineteen,ninety,octillion

1010 data "","","",nonillion

 

{{out}}

=={{header|Common Lisp}}==

 

 

=={{header|D}}==

{{trans|Python}}

use -version=number_names_main to see the output.

 

immutable tens = ["", "", "twenty", "thirty", "forty",

writeln;

}

{{out}}

<pre> +0 -> zero

2 -> two

0 -> zero</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

@small ~w(zero one two three four five six seven eight nine ten

eleven twelve thirteen fourteen fifteen sixteen seventeen

e in ArgumentError -> IO.puts Exception.message(e)

end

 

{{out}}

=={{header|Erlang}}==

 

-module(nr2eng).

-import(lists, [foreach/2, seq/2, append/2]).

end,

append(seq(1, 2000), [123123, 43234234])).

{{out}}

<pre>

=={{header|Euphoria}}==

{{trans|BASIC}}

if i < 0 then

return -i

puts(1,int2text(1234567890) & "\n")

puts(1,int2text(-987654321) & "\n")

 

{{out}}

=={{header|F_Sharp|F#}}==

{{trans|OCaml}}

 

let join = String.concat ", "

join (List.map big fsegn)

 

=={{header|Factor}}==

Factor "cheats" by having a standard library module for this task:

 

IN: scratchpad 43112609 number>text print

forty-three million, one hundred and twelve thousand, six hundred and nine

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

implicit none

end do

 

Sample input:

<pre>-1

forty-two

two billion one hundred forty-seven million four hundred eighty-three thousand six hundred forty-seven</pre>

 

 

 

 

 

=={{header|Go}}==

Supports integers from <code>math.MinInt64 + 1</code> to <code>math.MaxInt64</code>.

 

import "fmt"

}

return t

Output:

<pre>

 

=={{header|Groovy}}==

def qr = number.divideAndRemainder(divisor)

[div:qr[0], remainder:qr[1]]

verifyToText 'one million and forty five', 1000045

verifyToText 'one million and fifteen', 1000015

Output:

<pre>twenty nine

 

=={{header|Haskell}}==

 

spellInteger :: Integer -> String

big (e, n) = spellInteger n ++ ' ' : (l !! e) ++ "illion"

where l = [undefined, undefined, "m", "b", "tr", "quadr",

 

=={{header|HicEst}}==

CHARACTER outP*255, small*130, tens*80, big*80

REAL :: decimal_places = 7

TENS=ten twenty thirty forty fifty sixty seventy eighty ninety

 

1234 = one thousand and two hundred thirty-four

12.34 = twelve point three four

32768 = thirty-two thousand and seven hundred sixty-eight

1E-3 = point zero zero one

 

 

procedure main(arglist)

every x := !arglist do

write(commas(x), " -> ",spell(x))

 

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/numbers.icn numbers:spell] was used as a based for this procedure.

 

local m, i

static scale

}

else fail # really big

Sample output:

<pre>#spell.exe 5 11 15 67 10132767 65535 -1234567890123456

=={{header|Inform 7}}==

{{works with|Z-machine}}

 

{{works with|Glulx virtual machine}}

 

'''Solutions:'''

v=. ;:'ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen'

t=. ;:'twenty thirty forty fifty sixty seventy eighty ninety'

 

uk=: ' and '&en NB. British

 

'''Example:'''

us 1234567890123456789012345678901234567890123456789012345678901234567890x

one duovigintillion, two hundred thirty-four unvigintillion, five hundred sixty-seven vigintillion, eight hundred ninety novemdecillion, one hundred twenty-three octodecillion, four hundred fifty-six septendecillion, seven hundred eighty-nine sexdecillion, twelve quindecillion, three hundred forty-five quattuordecillion, six hundred seventy-eight tredecillion, nine hundred one duodecillion, two hundred thirty-four undecillion, five hundred sixty-seven decillion, eight hundred ninety nonillion, one hundred twenty-three octillion, four hundred fifty-six septillion, seven hundred eighty-nine sextillion, twelve quintillion, three hundred forty-five quadrillion, six hundred seventy-eight trillion, nine hundred one billion, two hundred thirty-four million, five hundred sixty-seven thousand, eight hundred ninety</pre>

 

=={{header|Java}}==

 

;

 

return sb.toString().trim();

}

Output:

<pre>zero

===Recursive===

 

 

final private static String[] units = {"Zero","One","Two","Three","Four",

return convert(i / 1000000) + " Million " + ((i % 1000000 > 0)? " " + convert(i % 1000000):"") ;

}

 

=={{header|JavaScript}}==

{{trans|Groovy}}

 

const sayNumber = value => {

}

return name;

 

=={{header|Joy}}==

DEFINE units ==

 

tens ==

 

convert6 ==

[convert2]

ifte.

 

=={{header|jq}}==

# Tested with jq 1.4

#

end ;

 

Transcript (input followed by output):

"zero"

-0

12345678912345678

"twelve quadrillion, three hundred and forty five trillion, six hundred and seventy eight billion, nine hundred and twelve million, three hundred and forty five thousand, six hundred and seventy eight"

 

=={{header|Julia}}==

 

'''Number Names Functions'''

const teentext = ["eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen",

"seventeen", "eighteen", "nineteen"]

n < toobig || return "too big to say"

digits2text!(digits(n, base=10), use_short_scale)

 

'''Main'''

 

println("Some easy ones to start with\n")

println(" ", i, " is")

println(num2text(i, false))

 

{{out}}

 

There is an option to use the UK (rather than the US) method of spelling out numbers whereby 'and' is placed at strategic positions.

 

val oneNames = listOf(

println("Using UK representation:")

for (i in exampleNumbers) println("${"%20d".format(i)} = ${numToText(i, true)}")

 

{{out}}

 

=={{header|Liberty BASIC}}==

global outnum$

dim ones$(20),tens$(9),gr$(5),group(5)

data "ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"

data "twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"

{{out}}

<pre>

 

=={{header|Logo}}==

eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen}

 

end

 

 

=={{header|Lua}}==

===Original===

levels = {"thousand ", "million ", "billion ", "trillion ", "quadrillion ", "quintillion ", "sextillion ", "septillion ", "octillion ", [0] = ""}

iwords = {"ten ", "twenty ", "thirty ", "forty ", "fifty ", "sixty ", "seventy ", "eighty ", "ninety "}

end

 

 

===Alternate===

As used in [[Four is magic#Lua|Four is magic]]

local oneslist = { [0]="", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" }

local teenlist = { [0]="ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" }

for _, num in ipairs(numbers) do

print( string.format("%.f: '%s'", num, numname(num)) )

{{out}}

<pre style="height:30ex;overflow:scroll">-1: 'negative one'

 

=={{header|Maple}}==

number_name(2001);

 

"eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",

"fifteen", "sixteen", "seventeen", "eighteen",

Riffle[Select[

MapThread[StringJoin, {name /@ #, Reverse@big[[;; Length@#]]}] &@

 

=={{header|Maxima}}==

l: [99, 300, 310, 1501, 12609, 512609, 43112609, 77000112609, 2000000000100,

999999999999999999, 0, -99, -1501, -77000112609, -123456789987654321];

map( lambda([n], printf(true, "~20d ~r~%", n, n)), l)$

 

=={{header|MAXScript}}==

fn numToEng num =

(

ret = (toupper ret[1]) + (tolower (substring ret 2 -1)) -- make the first char uppercase and rest lowercase

return ret

 

Examples:

numtoeng 0

"Zero"

"Four hundred and twenty one million, seven hundred and fifty two thousand, three hundred and two"

 

 

=={{header|MiniScript}}==

teens = "ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen ".split

tys = " twenty thirty forty fifty sixty seventy eighty ninety".split

for n in [-1234, 0, 7, 42, 4325, 1000004, 214837564]

print n + ": " + numberName(n)

 

Output:

=={{header|Nim}}==

{{trans|Python}}

 

const

"decillion"]

 

proc spellInteger(n: int64): string

 

if n == 0: "" else: connect & c & spellInteger(n)

 

 

if e == 0:

spellInteger(n)

spellInteger(n) & " " & huge[e]

 

var n = n

while n != 0:

var e = 0

for x in base1000Rev(n):

inc e

reverse sq

while n != 0:

echo align($n, 14)," -> ",spellInteger(n)

<pre> 0 -> zero

-3 -> minus three

=={{header|Objeck}}==

{{trans|BASIC}}

class NumberNames {

small : static : String[];

}

}

 

output:

 

=={{header|Objective-C}}==

 

int main() {

}

return 0;

Output:

<pre>

=={{header|OCaml}}==

 

let join = String.concat ", " ;;

 

in

join(List.map big fsegn)

 

=={{header|PARI/GP}}==

my(tmp,s="");

if (n >= 1000000,

Edigit(n)={

["one", "two", "three", "four", "five", "six", "seven", "eight", "nine"][n]

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

 

const

writeln(2343454564356, ': ', spell(2343454564356));

writeln(2345286538456328, ': ', spell(2345286538456328));

Output:

 

 

=={{header|Perl}}==

 

 

=={{header|Phix}}==

Implemented as an [[Executable_library]] for use in [[Names_to_numbers#Phix|Names_to_numbers]].<br>

The distribution now contains builtins\ordinal.e which implements spell() as ordinal(atom n, bool bJustSpell=true), see the manual.

{{out}}

<pre style="font-size: 8px">

 

=={{header|PHP}}==

$smallNumbers = array('Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine',

'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eighteen', 'Nineteen');

// The number is zero

return $str . "{$smallNumbers[(int)$thisPart]}";

Example:

NumberToEnglish(12);

NumberToEnglish(123);

NumberToEnglish(1234567890123);

NumberToEnglish(65535);

Returns:

<pre>Zero

 

=={{header|PicoLisp}}==

(cond

((=0 N) "zero")

(pack "-" (numNm (% N 10))) ) ) )

((rank N '((100 . "hundred") (1000 . "thousand") (1000000 . "million")))

 

=={{header|PL/I}}==

('zero', 'one', 'two', 'three', 'four', 'five', 'six',

'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve',

value = value ||h || v || y(i);

end;

 

=={{header|PowerBASIC}}==

Note that the PB compiler has some limitations related to how the <CODE>QUAD</CODE> data type is handled behind the scenes (extremely large values lose precision; see the sample output below the code).

 

IF 0 = number THEN

FUNCTION = "zero"

#ENDIF

? int2Text(n)

 

Sample output:

 

=={{header|PowerShell}}==

function Get-NumberName

{

 

1, 234, 31337, 987654321 | Get-NumberName

{{Out}}

<pre>

 

=={{header|Prolog}}==

:- module(spell, [spell/2]).

 

spell(N, Rest),

string_concat(", ", Rest, S).

{{Out}}

<pre>

=={{header|PureBasic}}==

The range of integers handled has been set at an obscene 45 digits.

numberNames:

;small

CloseConsole()

EndIf

{{out}}

<pre>Give me an integer (or q to quit)! 3

one hundred tredecillion, two decillion, three hundred quadrillion, four</pre>

 

Note: This example is also used as a module in the [[Names to numbers#Python]] task and should be kept in-sync.

 

"fifty", "sixty", "seventy", "eighty", "ninety"]

SMALL = ["zero", "one", "two", "three", "four", "five",

n //= -10

print('%-12i -> %s' % (n, spell_integer(n)))

 

{{out}}

An alternative solution that can name very large numbers.

 

def int_to_english(n):

if n < 0: return "minus " + int_to_english(-n)

print(int_to_english(2 ** 100))

print(int_to_english(10 ** (2*64)))

{{out}}

<pre>

one vigintillion vigintillion

</pre>

 

=={{header|R}}==

Can do zero and negatives.

 

ones <- c("", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",

my_num$text <- as.character(lapply(my_num$nums, make_number))

print(my_num, right=F)

 

{{out}}

=={{header|Racket}}==

 

#lang racket

 

(define r (+ (* e (random e)) (random e)))

(printf "~s: ~a\n" r (integer->english r)))

 

{{out}}

 

Apart from the <tt>$m++</tt> this can be viewed as a purely functional program; we use nested <tt>gather</tt>/<tt>take</tt> constructs to avoid accumulators.

ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen>;

constant @X = <0 X twenty thirty forty fifty sixty seventy eighty ninety>;

while '' ne (my $n = prompt("Number: ")) {

say int-name($n);

Output:

<pre>Number: 0

Alternately, we could use the [https://modules.raku.org/search/?q=Lingua%3A%3AEN%3A%3ANumbers Lingua::EN::Numbers module from the Raku ecosystem]. It will return similar output for similar inputs as above, but also handles fractions with configurable reduction and denominator, exponential notation, and ordinal notation.

 

 

put join "\n", .&cardinal, .&cardinal(:improper) with -7/4;

put join "\n", .&cardinal, .&cardinal-year, .&ordinal, .&ordinal-digit with 1999;

 

 

<pre>negative one and three quarters

this simple script available [https://github.com/AbdelrahmanGIT/RingSamples/blob/master/src/ConvertNumbersToString.ring here]

 

OneList=["zero", "one", "two", "three", "four",

"five", "six", "seven", "eight", "nine",

return str2list(str)

 

{{out}}

for input of:

{{works with|Ruby|1.9.2+}}

 

eleven twelve thirteen fourteen fifteen sixteen seventeen

eighteen nineteen)

puts "Error: #{e}"

end

{{out}}

<pre>

 

=={{header|Rust}}==

 

const SMALL: &[&str] = &[

write!(&mut stdout, "\n").unwrap();

}

 

{{out}}

=={{header|Scala}}==

{{libheader|Scala}}

import scala.collection.parallel.ParSeq

 

 

}.seq.sorted.foreach(num => println(f"$num%+,80d -> ${longhand(numeral = num, showAnd = true)}"))

 

{{out}}

=== Recursive ===

Recursive TreeMap solution (for values up to trillions):

 

val NUMBERS = TreeMap(

}

}

 

Examples

The library [http://seed7.sourceforge.net/libraries/wrinum.htm wrinum.s7i] contains the function [http://seed7.sourceforge.net/libraries/wrinum.htm#str%28ENGLISH,in_integer%29 str(ENGLISH, ...)] which converts an integer to its written english equivalent.

 

include "stdio.s7i";

include "wrinum.s7i";

var integer: number is 0;

begin

writeln(str(ENGLISH, number));

end for;

 

=={{header|SenseTalk}}==

set numbers to [0,1,7,22,186,pi,-48.6,-3451,925734, 12570902378]

 

put output

end repeat

Output:

<pre>

=={{header|SequenceL}}==

Works on all 32 bit signed integers.<br>

import <Utilities/Sequence.sl>;

import <Utilities/Conversion.sl>;

in

 

{{out}}

one hundred and twenty-three million, four hundred and fifty-six thousand, seven hundred and eighty-nine"

</pre>

 

=={{header|Sidef}}==

 

{{out}}

 

=={{header|SQL}}==

select val, to_char(to_date(val,'j'),'jsp') name

from

 

select to_char(to_date(5373485,'j'),'jsp') from dual;

<pre>

VAL NAME

{{trans|Kotlin}}

 

private static let bigNames = [

1_000: "thousand",

for number in nums {

print("\(number) => \(number.numberName)")

 

{{out}}

 

=={{header|Tcl}}==

if { ! [regexp -- {^(-?\d+)$} $n -> n]} {

error "not a decimal integer"

catch {int2words $test} result

puts "$test -> $result"

produces

<div style="width:full;overflow:scroll">

 

=={{header|VBA}}==

Public decades As Variant

Public orders As Variant

Debug.Print Format(smartp(si), "@@@@@@@@@@@@@@@@"); " "; spell(si)

Next i

<pre> 99 ninety-nine

300 three hundred

 

If one were to use variants further and get them to play nice as <code>Decimal</code>, this could theoretically be extended up to the octillion range.

 

Private small As Variant, tens As Variant, big As Variant

 

int2Text$ = Trim$(outP)

 

Example output (in a msgbox) is identical to the BASIC output.

This solution works for integers up to 1000. It should be fairly ovbious how it works, and so can be extended if needed.

 

Sub Main()

End Function

 

 

=={{header|Wren}}==

{{trans|Go}}

Although the third example here works correctly, it is not safe to use this script for numbers with an absolute magnitude >= 2^53 as integers cannot be expressed exactly by Wren's Num type beyond that limit.

"twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]

 

t = t + small[(n/100).floor] + " hundred"

var s = n % 100

if (s > 0) t = t + " " + say.call(s)

} else {

n = (n/1000).floor

if (p > 0) {

var ix = say.call(p) + illions[i]

if (sx != "") ix = ix + " " + sx

}

 

 

{{out}}

 

=={{header|XPL0}}==

 

proc NumName(Dev, Num); \Output integer Num in prose to device Dev

NumName(0, 1_000_000); CrLf(0);

NumName(0, 1_234_567_890); CrLf(0);

 

{{out}}

=={{header|zkl}}==

{{trans|Scala}}

ns =[1..20].chain([30..90,10]).walk(),

names=T("one","two","three","four","five","six","seven","eight","nine",

}else ""

}(n).strip() // sometimes there is a trailing space

println("%,d is %s".fmt(n,numberToString(n)));

{{out}}

<pre>