Names to numbers: Difference between revisions

* [[Number names]] — the reverse operation.

 

 

 

 

 

 

 

 

 

{{out}}

 

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

A counterpart to (format t "~R" ...).

(:use cl))

 

(format t "~a => ~a => ~a~%" number word (parse word))))

test-numbers))

Running the test procedure:

number => (format t "~R" number) => (parse (format t "~R" number))

0 => zero => 0

-2 => negative two => -2

0 => zero => 0

 

=={{header|Factor}}==

This solution parses number names in the same format that Factor's existing <code>number>text</code> word outputs. Meaning that for numbers under 10^66, <code>number>text</code> and <code>text>number</code> ought to be inverses of each other.

math.parser multiline peg peg.ebnf sequences sequences.deep ;

 

[ dup text>number "%s => %u\n" printf ] each ;

 

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

}

}

 

{{out}}

=={{header|Haskell}}==

{{trans|Common Lisp}}

 

type Symbol = (String, Integer)

("zero":[]) -> 0

("negative":wx') -> negate $ parse illions wx'

 

=={{header|J}}==

Define the verb usinv to convert number names to numbers.

File number_names.ijs contains the code of [[Number_names#J|number names project]].

NB. standard profile defines tolower and delete extra blanks.

load'number_names.ijs'

 

cut =: #@:[ }.&.> [ (E. <;.1 ]) ,

 

M +/ .*+/"1 ,"2 (([: (* 100 ^ 2 ~: #) (#EN100)|EN100&i.)&>)D

)

<pre>

(-: [&.(us :.usinv))0

</pre>

 

 

=={{header|Julia}}==

"six", "seven", "eight", "nine"]

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

words = split(strip(txt), r"(\s+)|(\s*\-\s*)")

phrases, num, alph = Vector{Pair{Bool, Vector{String}}}(), false, false

if isnumeric(word) && (num || word != "and")

if !num

push!(phrases, Pair(false, String[]))

num, alph = false, true

end

push!(phrases[end][2], word)

end

end

end

Change due: zero dollars and thirty-seven cents

One hour, fifty-nine minutes, forty point two seconds

Two Thousand Nineteen

Two Thousand Zero Hundred and Nineteen

println(txt, " => ", texttointeger(txt))

end

<pre>

One Hundred and One Dalmatians => 101 Dalmatians

Four Score And Seven Years Ago => 4 Score 7 Years Ago

two hundred pairs of socks => 200 pairs of socks

Always give one hundred and ten percent effort => Always give 110 percent effort

Change due: zero dollars and thirty-seven cents => Change due: 0 dollars and 37 cents

One hour, fifty-nine minutes, forty point two seconds => 1 hour, 59 minutes, 40 point 2 seconds

Two Thousand Nineteen => 2019

Two Thousand Zero Hundred and Nineteen => 2019

 

=={{header|Kotlin}}==

 

val names = mapOf<String, Long>(

)

for (name in names) println("${"%20d".format(nameToNum(name))} = $name")

 

{{out}}

-9223372036854775808 = minus nine quintillion, two hundred and twenty-three quadrillion, three hundred and seventy-two trillion, thirty-six billion, eight hundred and fifty-four million, seven hundred and seventy-five thousand, eight hundred and eight

</pre>

 

=={{header|Perl}}==

use warnings;

use feature 'say';

 

my $phrases_with_numbers = <<'END';

 

say $_ . ' --> ' . numify($_) for grep { $_ } split "\n", $phrases_with_numbers;

<pre>One Hundred and One Dalmatians --> 101 dalmatians

Two Thousand and One: A Space Odyssey --> 2001 : a space odyssey

Eighty-Eight Hundred Eighty-Eight --> 8888

one quadrillion, two trillion, three billion, four million, five thousand six --> 1,002,003,004,005,006</pre>

 

=={{header|Phix}}==

Uses [[Number_names#Phix|Number_names]] as an executable library.

{{Out}}

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

 

<small>Note: This example and [[Number_names#Python]] need to be kept in sync</small>

 

def int_from_words(num):

num = int_from_words(txt)

print('%12i <%s> %s' % (n, '==' if n == num else '??', txt))

{{out}}

<pre>##

-2 <==> minus two

0 <==> zero</pre>

 

=={{header|Racket}}==

Extension of the [[Number_names#Racket | number to names]] code:

 

#lang racket

 

(printf "~s <-> ~a\n" n eng)

(printf "Fail: ~s -> ~a -> ~s\n" n eng n2)))

 

{{out}}

552966175718680570 <-> five hundred and fifty-two quadrillion, nine hundred and sixty-six trillion, one hundred and seventy-five billion, seven hundred and eighteen million, six hundred and eighty thousand, five hundred and seventy

</pre>

 

=={{header|Ruby}}==

This solution uses "Number names" from [[Number_names#Ruby | here]]

{{trans|Python}}

 

def int_from_words(num)

end

negmult * (total + small)

 

Examples:

raise unless n == int_from_words(wordify(n))

end

break if n==0

n /= -10

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

 

static nums = Hash.new(

str.gsub!(/\b(\d{2}) (\d{2})\b/, {|a,b| (a.to_i * 100) + b.to_i});

str.gsub!(regex[10], {|a| a.split(' ').map{.to_i}.sum });

 

Usage:

say "#{line.chomp.dump} --> #{names_to_number(line).dump}";

 

Sample:

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

proc name2num name {

set words [regexp -all -inline {[a-z]+} [string tolower $name]]

}

return [expr {$sign * [tcl::mathop::+ {*}$groups]}]

Demonstrating/testing (based on [[#Perl|Perl]] code's samples):

"Seventy-two dollars"

"Seventy two dollars"

foreach s $samples {

puts "$s => [name2num $s]"

{{out}}

<pre>

one hundred eleven billion one hundred eleven => 111000000111

minus fifty six => -56

</pre>

 

=={{header|zkl}}==

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

"sixteen","seventeen","eighteen","nineteen","twenty",

}

minus*(total + hund)

" one hundred and fifty-five thousand and nineteen",

"one thousand, nine hundred and eighty-four","Nineteen Eighty-Four",

"six million, seven hundred and sixty-six thousand and twenty-seven")){

println("\"%s\" is %,d".fmt(s,stringToNumber(s)));

{{out}}

<pre>