Four is magic: Difference between revisions

:*   [[De Bruijn sequences]]

<br><br>

 

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

nety is eighteen, eighteen is eight, eight is five, five is four, four is

magic.</pre>

 

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

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

"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|Delphi}}==

{{libheader| System.SysUtils}}

program Four_is_magic;

 

writeln(fourIsMagic(n));

readln;

{{out}}

<pre>Zero is four, four is magic.

Negative one hundred and sixty-four is thirty-five, thirty-five is eleven, eleven is six, six is three, three is five, five is four, four is magic.

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 seven is two hundred and twenty-two, two hundred and twenty-two is twenty-six, twenty-six is ten, ten 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>

 

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

123456: One centenas twenty-three thousand four centenas fifty-six is fifty-eight, fifty-eight is eleven, eleven is six, six is three, three is five, five is four, four is magic.

1010101: One million ten thousand one centenas one is forty-one, forty-one is nine, nine is four, four is magic.

</pre>

 

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

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

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>

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>

</pre>

 

 

 

 

name_of() {

 

return 0

fi

 

# find the largest power of 10 that is smaller than n

 

# if we found one, split on it and construct quotient 'name' remainder

if (( n >= p )); then

local -i quotient=n/p

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

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

Nine is four, four is magic.

</pre>

 

 

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>