Names to numbers: Difference between revisions

{{trans|Nim}}

 

‘two’ = 2,

‘three’ = 3,

 

L(name) names

 

{{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|D}}==

This uses the D module from the Number names task.

{{trans|Python}}

std.range, number_names;

 

auto num = txt.bigIntFromWords;

writefln("%12d <%s> %s", n, (n == num) ? "==" : "??", txt);

{{out}}

<pre>This shows <==> for a successful round trip, <??> otherwise:

{{libheader| System.Math}}

{{Trans|Kotlin}}

program Names_to_numbers;

 

Names.free;

Readln;

{{out}}

<pre> 0 = none

=={{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

'''Works with gojq, the Go implementation of jq'''

 

if cond then . else msg | error end;

 

 

tests[]

{{out}}

Exactly as for [[#Wren|Wren]].

 

=={{header|Julia}}==

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

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

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

end

<pre>

One Hundred and One Dalmatians => 101 Dalmatians

 

=={{header|Kotlin}}==

 

val names = mapOf<String, Long>(

)

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

 

{{out}}

=={{header|Nim}}==

{{trans|Kotlin}}

 

const Names = {"one": 1u64,

 

for name in names:

 

{{out}}

 

=={{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

=={{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>##

Finally, the compiled nest is executed with <code>do</code>.

 

 

 

 

[ $ "{{ " swap

witheach

[ dup char , = if

join ]

$ " }}" join

else

[ nested join ] ]

 

$ "one billion, two hundred and thirty four million, five hundred and sixty seven thousand, eight hundred and ninety"

 

{{out}}

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}}

(formerly Perl 6)

{{trans|Perl}}

One Hundred and One Dalmatians

Two Thousand and One: A Space Odyssey

 

say $_ ~ ' --> ' ~ .&numify for $phrases-with-numbers.split("\n").grep: *.so;

{{out}}

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

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>

{{libheader|Wren-fmt}}

Wren's built in Num type can only deal accurately with integers up to 16 digits long (plus or minus 2 ^ 53) so without resorting to BigInt (which would be overkill here) we can only deal with numbers up to nine quadrillion or so.

var names = {

"one": 1,

"minus nine quadrillion, one hundred thirty-seven"

]

 

{{out}}

 

=={{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>