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

 

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

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.

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

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

 

let formatter = NumberFormatter()

formatter.numberStyle = .spellOut

result.append(" is magic.")

return result.joined()

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

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>