Four is magic: Difference between revisions

{{trans|Nim}}

‘five’, ‘six’, ‘seven’, ‘eight’, ‘nine’,

‘ten’, ‘eleven’, ‘twelve’, ‘thirteen’, ‘fourteen’,

L(n) [Int64(0), 4, 6, 11, 13, 75, 100, 337, -164, 7FFF'FFFF'FFFF'FFFF]

{{out}}

=={{header|8086 Assembly}}==

cpu 8086

bits 16

errhigh: db 'Max input 999999$'

section .bss

{{out}}

=={{header|APL}}==

{{works with|Dyalog APL}}

t20←'one' 'two' 'three' 'four' 'five' 'six' 'seven' 'eight' 'nine'

t20←t20,'ten' 'eleven' 'twelve' 'thirteen' 'fourteen' 'fifteen' 'sixteen'

n,' is ',(spell ≢n),', ',∇≢n

}⍵

{{out}}

<pre> magic 0

=={{header|AppleScript}}==

use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later

use framework "Foundation"

set end of output to fourIsMagic(n)

end repeat

{{output}}

Zero is four, four is magic.

Four is magic.

Thirty-two is ten, ten is three, three is five, five is four, four is magic.

One hundred eleven is eighteen, eighteen is eight, eight is five, five is four, four is magic.

=={{header|AutoHotkey}}==

Based on [http://www.rosettacode.org/wiki/Number_names#AutoHotkey Number names]

nubmer := num

while (num <> 4)

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

Return RegExReplace(n, "\B(?=((\d{3})+$))", ",")

result .= Four_is_magic(num) "`n"

Outputs:<pre>7 seven is five, five is four, four is magic!

54 fifty-four is ten, ten is three, three is five, five is four, four is magic!

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

=={{header|Clojure}}==

{{trans|UNIX Shell}}

(def names { 0 "zero" 1 "one" 2 "two" 3 "three" 4 "four" 5 "five"

6 "six" 7 "seven" 8 "eight" 9 "nine" 10 "ten" 11 "eleven"

(if (not= "repl" *command-line-args*)

(apply -main *command-line-args*))

{{Out}}

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

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

program Four_is_magic;

writeln(fourIsMagic(n));

readln;

{{out}}

<pre>Zero is four, four is magic.

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

=={{header|Fortran}}==

IMPLICIT NONE

CHARACTER(8), DIMENSION(20) :: SMALL_NUMS

ENDDO

END PROGRAM

<pre>

five is four, four is magic.

=={{header|FreeBASIC}}==

{{trans|Phix}}

#define floor(x) ((x*2.0-0.5) Shr 1)

Print Using "#######: &"; tests(i); fourIsMagic(tests(i))

Next i

{{out}}

<pre>

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

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

import (

}

return t

{{out}}

<pre>

Negative numbers are supported.

import Data.List (find)

putStrLn $ magic (-13)

putStrLn $ magic 999999

{{out}}

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

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

Define a simple function which generates the output, using FixedPointList to iterate until a magic number is reached.

FixedPointList[IntegerName[StringLength[#], "Cardinal"] &, IntegerName[num, "Cardinal"]],

Call the function a few times to show the expected output:

=={{header|Nim}}==

{{trans|Go}}

const

for n in [int64 0, 4, 6, 11, 13, 75, 100, 337, -164, int64.high]:

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

sub cardinal {

}

{{out}}

<pre>Zero is four, four is magic.

=={{header|Phix}}==

Note that on 32-bit Phix integers/atoms are only accurate to 9,007,199,254,740,992 (a hardware limit of 64-bit floating point registers) and on 64-bit the limit is 18,446,744,073,709,551,616 (ditto 80-bit floating points) so if you need more than that this will need to be reworked to use gmp or similar.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #000080;font-style:italic;">--&lt;adapted from demo\rosetta\number_names.exw, which alas outputs ",", "and", uses "minus" instead of "negative", etc...&gt;</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fourIsMagic</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]))</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

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

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

`eleven`twelve`thirteen`fourteen`fifteen`sixteen`seventeen`eighteen`nineteen / cardinal numbers <20

fim:{@[;0;upper],[;"four is magic.\n"] raze 1_{y," is ",x,", "}prior s each(count s@)\[x]} / four is magic

{{out}}

<pre>Zero is four, four is magic.

In q the same syntax applies a function to an argument or a list to its indexes. A consequence is that, with the Converge iterator <code>\</code> the lengths alone form a finite-state machine which can generate the convergence.

0 3 3 5 4 4 3 5 5 4 3 6 6 8 8 7 7 9 8 8

q)sl\[18]

18 8 5 4

q)sl\[19]

* [https://code.kx.com/q/ref/ Language Reference]

* [https://code.kx.com/q/learn/pb/four-magic/ The Q Playbook: Four is magic – analysis]

=={{header|R}}==

# provided by neonira

}

{{out}}

=={{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.*/

$= strip($ 'four is magic.') /*finish the sentence with the finale. */

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>

Using a 'refinement' to the Integer class, a way to a way to extend a class locally.

NUMBERS = { # taken from https://en.wikipedia.org/wiki/Names_of_large_numbers#cite_ref-a_14-3

[0, 4, 6, 11, 13, 75, 337, -164, 9_876_543_209].each{|n| puts magic4(n) }

{{out}}<pre>Zero is four, four is magic.

Four is magic.

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

=={{header|Swift}}==

func fourIsMagic(_ number: NSNumber) -> String {

for testInput in [23, 1000000000, 20140, 100, 130, 151, -7] {

print(fourIsMagic(testInput as NSNumber))

{{out}}

<pre>

=={{header|UNIX Shell}}==

{{works with|Bash|4+}}

name_of() {

# return the English name for a numeric value

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

fi

{{Out}}

=={{header|Vlang}}==

{{trans|go}}

fn main() {

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

}

return t

{{out}}

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",

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>