Four is magic: Difference between revisions

:*   [[Number names]]

:*   [[Self-describing numbers]]

:*   [[Spelling of ordinal numbers]]

<br><br>

 

=={{header|AWK}}==

# syntax: GAWK -f FOUR_IS_MAGIC.AWK

BEGIN {

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

}

{{out}}

<pre>

=={{header|C}}==

{{libheader|GLib}}

#include <stdio.h>

#include <glib.h>

test_magic(10344658531277200972ULL);

return 0;

 

{{out}}

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

Negative numbers are not supported.

#include <string>

#include <cctype>

test_magic(10344658531277200972ULL);

return 0;

 

{{out}}

Ten quintillion three hundred forty-four quadrillion six hundred fifty-eight trillion five hundred thirty-one billion two hundred seventy-seven million two hundred thousand nine hundred seventy-two is one hundred ninety-seven, one hundred ninety-seven is twenty-four, twenty-four is eleven, eleven is six, six is three, three is five, five is four, four is magic.

</pre>

 

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

(format nil "~@(~A~)" (with-output-to-string (out)

(loop for n = int then (length c)

while (/= n 4)

do (format out "~A is ~R, " c (length c))

 

{{out}}

<pre>

"One thousand twenty-four is twenty-four, twenty-four is eleven, eleven is six, six is three, three is five, five is four, four is magic."

</pre>

 

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

===The Function===

//Express an Integer in English Language. Nigel Galloway: September 19th., 2018

let fN=[|[|"";"one";"two";"three";"four";"five";"six";"seven";"eight";"nine"|];

|α when α<1000 ->I2α (α-(α/100)*100) (β+fN.[0].[α/100]+" hunred"+if α%100>0 then " and " else "")

|α when α<1000000->I2α (α%1000) (β+(I2α (α/1000) "")+" thousand"+if α%100=0 then "" else if (α-(α/1000)*1000)<100 then " and " else " ")

===The Task===

let rec printI2α=function |0->printf "naught->"; printI2α 6

|4->printfn "four is magic"

let N=System.Random()

List.init 25 (fun _->N.Next 999999) |> List.iter printI2α

{{out}}

<pre>

=={{header|Factor}}==

Factor's <code>math.text.english</code> vocabulary does most of the heavy lifting. Since <code>number>text</code> produces <tt><i>" and "</i></tt> and <tt><i>","</i></tt> in its output, they are removed with a regular expression.

sequences ;

IN: rosetta-code.four-is-magic

len-chain [ phrase ] map concat capitalize print ;

{{out}}

<pre>

Negative six hundred twelve thousand three hundred twelve is fifty-seven, fifty-seven is eleven, eleven is six, six is three, three is five, five is four, four is magic.

</pre>

 

=={{header|Go}}==

Uses the <code>say</code> function from the

[[Number names#Go|Number names]] task.

 

import (

}

return t

{{out}}

<pre>

Negative one hundred sixty-four is thirty-one, thirty-one is ten, ten is three, three is five, five is four, four is magic.

Nine quintillion two hundred twenty-three quadrillion three hundred seventy-two trillion thirty-six billion eight hundred fifty-four million seven hundred seventy-five thousand eight hundred seven is one hundred ninety-six, one hundred ninety-six is twenty-two, twenty-two is ten, ten is three, three is five, five is four, four is magic.

</pre>

 

=={{header|J}}==

names =. 'one';'two';'three';'four';'five';'six';'seven';'eight';'nine';'ten';'eleven';'twelve';'thirteen';'fourteen';'fifteen';'sixteen';'seventeen';'eighteen';'nineteen'

 

doall inputs

 

{{out}}

 

 

=={{header|Java}}==

public class FourIsMagic {

 

 

}

{{out}}

<pre>

 

To test whether a particular JavaScript interpreter implements <code>BigInt</code>, we can evaluate a boolean expression like:

 

const rawNumberToTextMapping = { // Ported over from the Python solution.

[1n]: "one",

-4,

10n ** 3003n + 42n

 

{{output}}

One millinillion forty two is twenty six, twenty six is ten, ten is three, three is five, five is four, four is magic.

</pre>

 

=={{header|Julia}}==

 

const stext = ["one", "two", "three", "four", "five",

magic(n)

end

Zero is four, four is magic.

Four is magic.

=={{header|Kotlin}}==

This uses the code I wrote for the [[Number names]] task, appropriately adjusted to deal with this task. Input is limited to '''signed''' 64 bit integers as Kotlin doesn't currently support unsigned types.

 

val names = mapOf(

println()

}

 

{{out}}

 

=={{header|Lua}}==

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(num, fourismagic(num))

{{out}}

<pre>-21 Negative twenty-one is nineteen, nineteen is eight, eight is five, five is four, four is magic.

123456 One hundred twenty-three thousand four hundred fifty-six is fifty-six, fifty-six is nine, nine is four, four is magic.

1010101 One million ten thousand one hundred one is forty, forty is five, five is four, four is magic.</pre>

 

=={{header|Perl}}==

{{trans|Raku}}

 

sub cardinal {

}

 

{{out}}

<pre>Zero is four, four is magic.

 

=={{header|Phix}}==

{{out}}

<pre>

Python 3 version. Should work for integers up to at least 10^3003. It can be extended easily to arbitrary integers by adding to the numbers dict.

 

from collections import OrderedDict

 

 

for j in (random.randint(-10 ** 24, 10 ** 24) for i in range(2)):

 

{{out}}

874143425855745733896030 :

Eight hundred seventy four sextillion one hundred forty three quintillion four hundred twenty five quadrillion eight hundred fifty five trillion seven hundred forty five billion seven hundred thirty three million eight hundred ninety six thousand thirty is two hundred fifty three, two hundred fifty three is twenty three, twenty three is twelve, twelve is six, six is three, three is five, five is four, four is magic. </pre>

 

=={{header|Racket}}==

#lang racket

 

(displayln (number-magic n))

(newline))

 

{{out}}

Lingua::EN::Numbers module available from the [https://modules.raku.org/search/?q=Lingua%3A%3AEN%3A%3ANumbers Raku ecosystem].

 

 

sub card ($n) { cardinal($n).subst(/','/, '', :g) }

}

 

{{out}}

<pre style="width:98%;overflow:wrap;">Zero is four, four is magic.

 

Numbers are limited to 3,003 decimal digits, the maximum number that the &nbsp; '''$SPELL#''' &nbsp; REXX program will handle.

numeric digits 3003 /*be able to handle gihugic numbers. */

parse arg x /*obtain optional numbers from the C.L.*/

do j=1 for words(x) /*process each of the numbers in list. */

say 4_is( word(x, j) ) /*display phrase that'll be returned. */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

if #\==4 then do until L==4 /*Not 4? Process number.*/

end /*until*/ /* ··· which will be spelt*/

parse var $ first 2 other; upper first /*capitalize the first letter of output*/

The &nbsp; '''$SPELL#.REX''' &nbsp; routine can be found here &nbsp; ───► &nbsp; [[$SPELL.REX|$SPELL#.REX]]. <br><br>

 

=={{header|Ring}}==

 

/* Checking numbers from 0 to 10 */

for c = 0 to 10

Return trim(Result)

Output:

<pre>

Ten is three, three is five, five is four, four is magic.

</pre>

 

 

=={{header|Rust}}==

magic(4);

magic(2_340);

}

return cur;

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

static lingua_en = frequire("Lingua::EN::Numbers")

lingua_en.num2en(n) - / and|,/g

[0, 4, 6, 11, 13, 75, 337, -164, 9_876_543_209].each { |n|

say four_is_magic(n)

{{out}}

<pre>

</pre>

 

 

 

 

name_of() {

 

return 0

fi

 

local -i i=0

local -i p=${powers_of_10[i]}

remname=$(name_of $remainder)

fi

# things are a little different under 100, since the multiples of

# 10 have their own names

remname=-$(name_of $remainder)

fi

fi

 

four_is_magic "$len" "${prefix:+$prefix, }$name is $(name_of $len)"

fi

 

{{Out}}

<pre>

# but this is that value minus the first digit (40 quintillion)

$ four_is_magic 3252003274489856000

Eight is five, five is four, four is magic.

Nine is four, four is magic.

 

 

=={{header|Wren}}==

 

Note that 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.

 

var small = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven",

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

for (n in [0, 4, 6, 11, 13, 75, 100, 337, -164, 9007199254740991]) {

System.print(fourIsMagic.call(n))

 

{{out}}

Uses the nth function from [[Spelling_of_ordinal_numbers#zkl]]

 

if(int==0) return("Zero is four, four is magic.");

string:="";

}

string[0].toUpper() + string[1,*]

println(fourIsMagic(n),"\n")

{{out}}

<pre>