Data commit
This commit is contained in:
Ingy döt Net
parent
7387c8f97b
commit
cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
2
Task/Four-is-magic/00-META.yaml
Normal file
2
Task/Four-is-magic/00-META.yaml
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Four_is_magic
|
||||
57
Task/Four-is-magic/00-TASK.txt
Normal file
57
Task/Four-is-magic/00-TASK.txt
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
;Task:
|
||||
Write a subroutine, function, whatever it may be called in your language, that takes an integer number and returns an English text sequence starting with the English cardinal representation of that integer, the word 'is' and then the English cardinal representation of the count of characters that made up the first word, followed by a comma.
|
||||
|
||||
Continue the sequence by using the previous count word as the first word of the next phrase, append 'is' and the cardinal count of the letters in ''that'' word.
|
||||
|
||||
Continue until you reach four. Since four has four characters, finish by adding the words 'four is magic' and a period. All integers will eventually wind up at four.
|
||||
|
||||
For instance, suppose your are given the integer '''3'''. Convert '''3''' to '''Three''', add ''' is ''', then the cardinal character count of three, or '''five''', with a comma to separate if from the next phrase. Continue the sequence '''five is four,''' (five has four letters), and finally, '''four is magic.'''
|
||||
|
||||
'''Three is five, five is four, four is magic.'''
|
||||
|
||||
For reference, here are outputs for 0 through 9.
|
||||
|
||||
Zero is four, four is magic.
|
||||
One is three, three is five, five is four, four is magic.
|
||||
Two is three, three is five, five is four, four is magic.
|
||||
Three is five, five is four, four is magic.
|
||||
Four is magic.
|
||||
Five is four, four is magic.
|
||||
Six is three, three is five, five is four, four is magic.
|
||||
Seven is five, five is four, four is magic.
|
||||
Eight is five, five is four, four is magic.
|
||||
Nine is four, four is magic.
|
||||
|
||||
|
||||
;Some task guidelines:
|
||||
:* You may assume the input will only contain integer numbers.
|
||||
:* Cardinal numbers between 20 and 100 may use either hyphens or spaces as word separators but they must use a word separator. ('''23''' is '''twenty three''' or '''twenty-three''' not '''twentythree'''.)
|
||||
:* Cardinal number conversions should follow the [[wp:Long_and_short_scales| English short scale]]. (billion is 1e9, trillion is 1e12, etc.)
|
||||
:* Cardinal numbers should not include commas. ('''20140''' is '''twenty thousand one hundred forty''' not '''twenty thousand, one hundred forty'''.)
|
||||
:* When converted to a string, '''100''' should be '''one hundred''', not '''a hundred''' or '''hundred''', '''1000''' should be '''one thousand''', not '''a thousand''' or '''thousand'''.
|
||||
:* When converted to a string, there should be no '''and''' in the cardinal string. '''130''' should be '''one hundred thirty''' not '''one hundred and thirty'''.
|
||||
:* When counting characters, count ''all'' of the characters in the cardinal number including spaces and hyphens. '''One hundred fifty-one''' should be '''21''' not '''18'''.
|
||||
:* The output should follow the format "N is K, K is M, M is ... four is magic." (unless the input is 4, in which case the output should simply be "four is magic.")
|
||||
:* The output can either be the return value from the function, or be displayed from within the function.
|
||||
:* You are encouraged, though not mandated to use proper sentence capitalization.
|
||||
:* You may optionally support negative numbers. '''-7''' is '''negative seven'''.
|
||||
:* Show the output here for a small representative sample of values, at least 5 but no more than 25. You are free to choose which which numbers to use for output demonstration.
|
||||
|
||||
|
||||
You can choose to use a library, (module, external routine, whatever) to do the cardinal conversions as long as the code is easily and freely available to the public.
|
||||
|
||||
If you roll your own, make the routine accept at minimum any integer from 0 up to 999999. If you use a pre-made library, support at least up to unsigned 64 bit integers. (or the largest integer supported in your language if it is less.)
|
||||
|
||||
Four is magic is a popular code-golf task. '''This is not code golf.''' Write legible, idiomatic and well formatted code.<BR>
|
||||
|
||||
|
||||
;Related tasks:
|
||||
:* [[Four is the number of_letters in the ...]]
|
||||
:* [[Look-and-say sequence]]
|
||||
:* [[Number names]]
|
||||
:* [[Self-describing numbers]]
|
||||
:* [[Summarize and say sequence]]
|
||||
:* [[Spelling of ordinal numbers]]
|
||||
:* [[De Bruijn sequences]]
|
||||
<br><br>
|
||||
|
||||
57
Task/Four-is-magic/11l/four-is-magic.11l
Normal file
57
Task/Four-is-magic/11l/four-is-magic.11l
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
V Small = [‘zero’, ‘one’, ‘two’, ‘three’, ‘four’,
|
||||
‘five’, ‘six’, ‘seven’, ‘eight’, ‘nine’,
|
||||
‘ten’, ‘eleven’, ‘twelve’, ‘thirteen’, ‘fourteen’,
|
||||
‘fifteen’, ‘sixteen’, ‘seventeen’, ‘eighteen’, ‘nineteen’]
|
||||
|
||||
V Tens = [‘’, ‘’, ‘twenty’, ‘thirty’, ‘forty’, ‘fifty’, ‘sixty’, ‘seventy’, ‘eighty’, ‘ninety’]
|
||||
|
||||
V Illions = [‘’, ‘ thousand’, ‘ million’, ‘ billion’, ‘ trillion’, ‘ quadrillion’, ‘ quintillion’]
|
||||
|
||||
F say(Int64 =n) -> String
|
||||
V result = ‘’
|
||||
I n < 0
|
||||
result = ‘negative ’
|
||||
n = -n
|
||||
|
||||
I n < 20
|
||||
result ‘’= Small[Int(n)]
|
||||
|
||||
E I n < 100
|
||||
result ‘’= Tens[Int(n I/ 10)]
|
||||
V m = n % 10
|
||||
I m != 0
|
||||
result ‘’= ‘-’Small[Int(m)]
|
||||
|
||||
E I n < 1000
|
||||
result ‘’= Small[Int(n I/ 100)]‘ hundred’
|
||||
V m = n % 100
|
||||
I m != 0
|
||||
result ‘’= ‘ ’say(m)
|
||||
|
||||
E
|
||||
V sx = ‘’
|
||||
V i = 0
|
||||
L n > 0
|
||||
V m = n % 1000
|
||||
n I/= 1000
|
||||
I m != 0
|
||||
V ix = say(m)‘’Illions[i]
|
||||
I sx.len > 0
|
||||
ix ‘’= ‘ ’sx
|
||||
sx = ix
|
||||
i++
|
||||
result ‘’= sx
|
||||
|
||||
R result
|
||||
|
||||
F fourIsMagic(=n)
|
||||
V s = say(n).capitalize()
|
||||
V result = s
|
||||
L n != 4
|
||||
n = s.len
|
||||
s = say(n)
|
||||
result ‘’= ‘ is ’s‘, ’s
|
||||
R result‘ is magic.’
|
||||
|
||||
L(n) [Int64(0), 4, 6, 11, 13, 75, 100, 337, -164, 7FFF'FFFF'FFFF'FFFF]
|
||||
print(fourIsMagic(n))
|
||||
203
Task/Four-is-magic/8086-Assembly/four-is-magic.8086
Normal file
203
Task/Four-is-magic/8086-Assembly/four-is-magic.8086
Normal file
|
|
@ -0,0 +1,203 @@
|
|||
puts: equ 9h ; MS-DOS syscall to print a string
|
||||
cpu 8086
|
||||
bits 16
|
||||
org 100h
|
||||
section .text
|
||||
;;; Read number from the MS-DOS command line
|
||||
;;; The task says numbers up to 999999 need to be
|
||||
;;; supported, so we can't get away with using MUL.
|
||||
mov cl,[80h] ; Is there an argument?
|
||||
test cl,cl
|
||||
jnz havearg
|
||||
mov ah,puts ; If not, print "no input"
|
||||
mov dx,errinput
|
||||
int 21h
|
||||
ret ; And stop.
|
||||
havearg: mov si,82h ; Start of argument string
|
||||
xor ch,ch ; CX = argument length
|
||||
dec cx ; Minus one (space before argument)
|
||||
xor ax,ax ; Accumulator starts out at 0
|
||||
xor dx,dx
|
||||
numloop: mov bp,ax ; DX:AX *= 10
|
||||
mov di,dx
|
||||
add ax,ax ; ... *2
|
||||
adc dx,dx
|
||||
add ax,ax ; ... *4
|
||||
adc dx,dx
|
||||
add ax,bp ; ... *5
|
||||
adc dx,di
|
||||
add ax,ax ; ... *10
|
||||
adc dx,dx
|
||||
mov bx,ax
|
||||
lodsb ; Get digit
|
||||
sub al,'0'
|
||||
xor ah,ah
|
||||
add ax,bx ; Add digit
|
||||
adc dx,0
|
||||
loop numloop ; Next digit if there is one
|
||||
;;; DX:AX now contains the binary representation of
|
||||
;;; the decimal input.
|
||||
cmp dx,0Fh ; Check that DX:AX <= 999999
|
||||
jb donum
|
||||
cmp ax,4240h ; 0F4240h = 1000000
|
||||
jb donum
|
||||
mov ah,puts ; Otherwise, print error message
|
||||
mov dx,errhigh
|
||||
int 21h
|
||||
ret
|
||||
;;; DX:AX = current number
|
||||
donum: push dx ; Keep number
|
||||
push ax
|
||||
mov di,numstring ; Create the string for the number
|
||||
call cardinal
|
||||
mov [di],byte '$'
|
||||
xor [numstring],byte 32 ; Capitalize first letter
|
||||
.print: mov dx,numstring ; Print the string
|
||||
mov ah,puts
|
||||
int 21h
|
||||
mov dx,is ; print ' is ',
|
||||
int 21h
|
||||
pop ax ; Retrieve number
|
||||
pop dx
|
||||
test dx,dx ; DX:AX = 4 = magic
|
||||
jnz .nomagic ; DX <> 0 = not magic
|
||||
cmp ax,4 ; If AX=4 then magic
|
||||
je .magic
|
||||
.nomagic: sub di,numstring ; Calculate length of string
|
||||
xor dx,dx ; Set DX:AX to DI
|
||||
mov ax,di
|
||||
push dx ; Store new number on stack
|
||||
push ax
|
||||
mov di,numstring ; Make string for new number
|
||||
call cardinal
|
||||
mov [di],byte '$'
|
||||
mov dx,numstring ; Print the string
|
||||
mov ah,puts
|
||||
int 21h
|
||||
mov dx,commaspace ; Print comma and space
|
||||
int 21h
|
||||
jmp .print ; Then use next number as input
|
||||
.magic: mov dx,magic ; print "magic.",
|
||||
mov ah,puts
|
||||
int 21h
|
||||
ret ; and stop
|
||||
;;; Subroutine: assuming 0 <= DX:AX <= 999999, write
|
||||
;;; cardinal representation at ES:DI.
|
||||
cardinal: mov bp,ax
|
||||
or bp,dx
|
||||
jz .zero ; If it is zero, return 'Zero'
|
||||
mov bp,1000 ; Otherwise, get 1000s part
|
||||
div bp
|
||||
test ax,ax ; Above 1000?
|
||||
jz .hundreds_dx ; If not, just find hundreds
|
||||
push dx ; Otherwise, save <1000s part,
|
||||
call .hundreds ; get string for how many thousands,
|
||||
mov si,thousand ; Then add ' thousand',
|
||||
call stradd
|
||||
pop dx ; Restore <1000 part,
|
||||
test dx,dx ; Even thousands?
|
||||
jnz .hundreds_spc ; Then add hundreds
|
||||
ret ; Otherwise we're done
|
||||
.hundreds_spc: mov al,' ' ; Add space betweeen thousand and rest
|
||||
stosb
|
||||
.hundreds_dx: mov ax,dx
|
||||
.hundreds: mov bp,100 ; Get hundreds part
|
||||
xor dx,dx
|
||||
div bp ; AX=100s
|
||||
test ax,ax ; If zero, no hundreds
|
||||
jz .tens_dx
|
||||
dec ax ; Otherwise, look up in singles
|
||||
shl ax,1 ; table,
|
||||
mov bx,ax
|
||||
mov si,[single+bx]
|
||||
call stradd ; Add to the output string,
|
||||
mov si,hundred ; Add ' hundred',
|
||||
call stradd
|
||||
test dx,dx ; Is there any more?
|
||||
jne .tens_spc ; If so, add tens
|
||||
ret ; Otherwise we're done
|
||||
.tens_spc: mov al,' ' ; Add space between 'hundred' and tens
|
||||
stosb
|
||||
.tens_dx: mov ax,dx ; Tens in AX (from hundreds)
|
||||
.tens: aam ; AH=10s digit, AL=1s digit
|
||||
test ah,ah ; If 10s digit is 0, single digit
|
||||
jz .ones
|
||||
cmp ah,1 ; If 10s digit is 1, teens
|
||||
jz .teens
|
||||
mov bl,ah ; Look up tens digit in tens table
|
||||
sub bl,2
|
||||
shl bl,1
|
||||
xor bh,bh
|
||||
mov si,[tens+bx] ; Add to the output string
|
||||
call stradd
|
||||
test al,al ; Ones digit left?
|
||||
jne .ones_dash ; If so, add dash and ones digit
|
||||
ret ; Otherwise we're done
|
||||
.ones_dash: mov [di],byte '-'
|
||||
inc di
|
||||
.ones: mov bl,al ; Look up ones digit in ones table
|
||||
dec bl
|
||||
shl bl,1
|
||||
xor bh,bh
|
||||
mov si,[single+bx]
|
||||
jmp stradd
|
||||
.teens: mov bl,al ; Look up ones digit in teens table
|
||||
shl bl,1
|
||||
xor bh,bh
|
||||
mov si,[teens+bx]
|
||||
jmp stradd
|
||||
.zero: mov si,zero
|
||||
;;; Copy $-terminated string at DS:SI to ES:DI, except
|
||||
;;; the terminator.
|
||||
stradd: push ax ; Keep AX register
|
||||
.loop: lodsb ; Get byte from DS:SI
|
||||
cmp al,'$' ; Are we there yet?
|
||||
je .out ; If so, stop
|
||||
stosb ; Otherwise, store at ES:DI
|
||||
jmp .loop
|
||||
.out: pop ax
|
||||
ret
|
||||
section .data
|
||||
single: dw one,two,three,four
|
||||
dw five,six,seven,eight,nine
|
||||
teens: dw ten,eleven,twelve,thirteen,fourteen
|
||||
dw fifteen,sixteen,seventeen,eighteen,nineteen
|
||||
tens: dw twenty,thirty,forty,fifty
|
||||
dw sixty,seventy,eighty,ninety
|
||||
zero: db 'zero$'
|
||||
one: db 'one$'
|
||||
two: db 'two$'
|
||||
three: db 'three$'
|
||||
four: db 'four$'
|
||||
five: db 'five$'
|
||||
six: db 'six$'
|
||||
seven: db 'seven$'
|
||||
eight: db 'eight$'
|
||||
nine: db 'nine$'
|
||||
ten: db 'ten$'
|
||||
eleven: db 'eleven$'
|
||||
twelve: db 'twelve$'
|
||||
thirteen: db 'thirteen$'
|
||||
fourteen: db 'fourteen$'
|
||||
fifteen: db 'fifteen$'
|
||||
sixteen: db 'sixteen$'
|
||||
seventeen: db 'seventeen$'
|
||||
eighteen: db 'eighteen$'
|
||||
nineteen: db 'nineteen$'
|
||||
twenty: db 'twenty$'
|
||||
thirty: db 'thirty$'
|
||||
forty: db 'forty$'
|
||||
fifty: db 'fifty$'
|
||||
sixty: db 'sixty$'
|
||||
seventy: db 'seventy$'
|
||||
eighty: db 'eighty$'
|
||||
ninety: db 'ninety$'
|
||||
hundred: db ' hundred$'
|
||||
thousand: db ' thousand$'
|
||||
is: db ' is $'
|
||||
magic: db 'magic.$'
|
||||
commaspace: db ', $'
|
||||
errinput: db 'No input$'
|
||||
errhigh: db 'Max input 999999$'
|
||||
section .bss
|
||||
numstring: resb 1024
|
||||
27
Task/Four-is-magic/APL/four-is-magic.apl
Normal file
27
Task/Four-is-magic/APL/four-is-magic.apl
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
magic←{
|
||||
t20←'one' 'two' 'three' 'four' 'five' 'six' 'seven' 'eight' 'nine'
|
||||
t20←t20,'ten' 'eleven' 'twelve' 'thirteen' 'fourteen' 'fifteen' 'sixteen'
|
||||
t20←t20,'seventeen' 'eighteen' 'nineteen'
|
||||
tens←'twenty' 'thirty' 'forty' 'fifty' 'sixty' 'seventy' 'eighty' 'ninety'
|
||||
spell←{
|
||||
⍵=0:'zero'
|
||||
{
|
||||
⍵=0:''
|
||||
⍵<20:⍵⊃t20
|
||||
⍵<100:∊tens[(⌊⍵÷10)-1],((0≠≢r)/'-'),r←∇10|⍵
|
||||
⍵<1000:(∇⌊⍵÷100),' hundred',((0≠≢r)/' '),r←∇100|⍵
|
||||
⍵<1e6:(∇⌊⍵÷1000),' thousand',((0≠≢r)/' '),r←∇1000|⍵
|
||||
⍵<1e9:(∇⌊⍵÷1e6),' million',((0≠≢r)/' '),r←∇1e6|⍵
|
||||
⍵<1e12:(∇⌊⍵÷1e9),' billion',((0≠≢r)/' '),r←∇1e9|⍵
|
||||
⍵<1e15:(∇⌊⍵÷1e12),' trillion',((0≠≢r)/' '),r←∇1e12|⍵
|
||||
⍵<1e18:(∇⌊⍵÷1e15),' quadrillion',((0≠≢r)/' '),r←∇1e15|⍵
|
||||
⍵<1e21:(∇⌊⍵÷1e18),' quintillion',((0≠≢r)/' '),r←∇1e18|⍵
|
||||
'Overflow' ⎕SIGNAL 11
|
||||
}⍵
|
||||
}
|
||||
1(819⌶)@1⊢{
|
||||
n←spell ⍵
|
||||
⍵=4:n,' is magic.'
|
||||
n,' is ',(spell ≢n),', ',∇≢n
|
||||
}⍵
|
||||
}
|
||||
62
Task/Four-is-magic/AWK/four-is-magic.awk
Normal file
62
Task/Four-is-magic/AWK/four-is-magic.awk
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
# syntax: GAWK -f FOUR_IS_MAGIC.AWK
|
||||
BEGIN {
|
||||
init_numtowords()
|
||||
n = split("-1 0 1 2 3 4 5 6 7 8 9 11 21 1995 1000000 1234567890 1100100100100",arr," ")
|
||||
for (i=1; i<=n; i++) {
|
||||
a = arr[i]
|
||||
printf("%s: ",a)
|
||||
do {
|
||||
if (a == 4) {
|
||||
break
|
||||
}
|
||||
a = numtowords(a)
|
||||
b = numtowords(length(a))
|
||||
printf("%s is %s, ",a,b)
|
||||
a = length(a)
|
||||
} while (b !~ /^four$/)
|
||||
printf("four is magic.\n")
|
||||
}
|
||||
exit(0)
|
||||
}
|
||||
# source: The AWK Programming Language, page 75
|
||||
function numtowords(n, minus,str) {
|
||||
if (n < 0) {
|
||||
n = n * -1
|
||||
minus = "minus "
|
||||
}
|
||||
if (n == 0) {
|
||||
str = "zero"
|
||||
}
|
||||
else {
|
||||
str = intowords(n)
|
||||
}
|
||||
gsub(/ /," ",str)
|
||||
gsub(/ $/,"",str)
|
||||
return(minus str)
|
||||
}
|
||||
function intowords(n) {
|
||||
n = int(n)
|
||||
if (n >= 1000000000000) {
|
||||
return intowords(n/1000000000000) " trillion " intowords(n%1000000000000)
|
||||
}
|
||||
if (n >= 1000000000) {
|
||||
return intowords(n/1000000000) " billion " intowords(n%1000000000)
|
||||
}
|
||||
if (n >= 1000000) {
|
||||
return intowords(n/1000000) " million " intowords(n%1000000)
|
||||
}
|
||||
if (n >= 1000) {
|
||||
return intowords(n/1000) " thousand " intowords(n%1000)
|
||||
}
|
||||
if (n >= 100) {
|
||||
return intowords(n/100) " hundred " intowords(n%100)
|
||||
}
|
||||
if (n >= 20) {
|
||||
return tens[int(n/10)] " " intowords(n%10)
|
||||
}
|
||||
return(nums[n])
|
||||
}
|
||||
function init_numtowords() {
|
||||
split("one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen",nums," ")
|
||||
split("ten twenty thirty forty fifty sixty seventy eighty ninety",tens," ")
|
||||
}
|
||||
53
Task/Four-is-magic/AppleScript/four-is-magic-1.applescript
Normal file
53
Task/Four-is-magic/AppleScript/four-is-magic-1.applescript
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
(* Uses a Foundation number formatter for brevity. *)
|
||||
use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
|
||||
use framework "Foundation"
|
||||
|
||||
on getNumberFormatter(localeID, numberStyle)
|
||||
set formatter to current application's class "NSNumberFormatter"'s new()
|
||||
tell formatter to setLocale:(current application's class "NSLocale"'s localeWithLocaleIdentifier:(localeID))
|
||||
tell formatter to setNumberStyle:(numberStyle)
|
||||
|
||||
return formatter
|
||||
end getNumberFormatter
|
||||
|
||||
on join(listOfText, delimiter)
|
||||
set astid to AppleScript's text item delimiters
|
||||
set AppleScript's text item delimiters to delimiter
|
||||
set txt to listOfText as text
|
||||
set AppleScript's text item delimiters to astid
|
||||
|
||||
return txt
|
||||
end join
|
||||
|
||||
on fourIsMagic(n)
|
||||
set n to n as number
|
||||
if (n is 4) then return "Four is magic."
|
||||
|
||||
set formatter to getNumberFormatter("en_US", current application's NSNumberFormatterSpellOutStyle)
|
||||
|
||||
set nName to (formatter's stringFromNumber:(n)) as text
|
||||
if (nName begins with "minus") then
|
||||
set nName to "Negative " & text from word 2 to -1 of nName
|
||||
else -- Crude ID-based capitalisation. Good enough for English number names.
|
||||
set nName to character id ((id of character 1 of nName) - 32) & text 2 thru -1 of nName
|
||||
end if
|
||||
|
||||
set output to {}
|
||||
repeat until (n is 4)
|
||||
set n to (count nName)
|
||||
set lenName to (formatter's stringFromNumber:(n)) as text
|
||||
set end of output to nName & " is " & lenName
|
||||
set nName to lenName
|
||||
end repeat
|
||||
set end of output to "four is magic."
|
||||
|
||||
return join(output, ", ")
|
||||
end fourIsMagic
|
||||
|
||||
local tests, output, n
|
||||
set tests to {-19, 0, 4, 25, 32, 111, 1.234565789E+9}
|
||||
set output to {}
|
||||
repeat with n in tests
|
||||
set end of output to fourIsMagic(n)
|
||||
end repeat
|
||||
return join(output, linefeed)
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
"Negative nineteen is seventeen, seventeen is nine, nine is four, four is magic.
|
||||
Zero is four, four is magic.
|
||||
Four is magic.
|
||||
Twenty-five is eleven, eleven is six, six is three, three is five, five is four, 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.
|
||||
One billion two hundred thirty-four million five hundred sixty-five thousand seven hundred eighty-nine is one hundred two, one hundred two is fifteen, fifteen is seven, seven is five, five is four, four is magic."
|
||||
27
Task/Four-is-magic/AutoHotkey/four-is-magic-1.ahk
Normal file
27
Task/Four-is-magic/AutoHotkey/four-is-magic-1.ahk
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
Four_is_magic(num){
|
||||
nubmer := num
|
||||
while (num <> 4)
|
||||
result .= (res := spell(num)) " is " spell(num := StrLen(res)) ", "
|
||||
return PrettyNumber(nubmer) " " result "four is magic!"
|
||||
}
|
||||
Spell(n) { ; recursive function to spell out the name of a max 36 digit integer, after leading 0s removed
|
||||
Static p1=" thousand ",p2=" million ",p3=" billion ",p4=" trillion ",p5=" quadrillion ",p6=" quintillion "
|
||||
, p7=" sextillion ",p8=" septillion ",p9=" octillion ",p10=" nonillion ",p11=" decillion "
|
||||
, t2="twenty",t3="thirty",t4="forty",t5="fifty",t6="sixty",t7="seventy",t8="eighty",t9="ninety"
|
||||
, o0="zero",o1="one",o2="two",o3="three",o4="four",o5="five",o6="six",o7="seven",o8="eight"
|
||||
, o9="nine",o10="ten",o11="eleven",o12="twelve",o13="thirteen",o14="fourteen",o15="fifteen"
|
||||
, o16="sixteen",o17="seventeen",o18="eighteen",o19="nineteen"
|
||||
If (11 < d := (StrLen(n)-1)//3) ; #of digit groups of 3
|
||||
Return "Number too big"
|
||||
If (d) ; more than 3 digits
|
||||
Return Spell(SubStr(n,1,-3*d)) p%d% ((s:=SubStr(n,1-3*d)) ? ", " Spell(s) : "")
|
||||
i := SubStr(n,1,1)
|
||||
If (n > 99) ; 3 digits
|
||||
Return o%i% " hundred" ((s:=SubStr(n,2)) ? " " Spell(s) : "")
|
||||
If (n > 19) ; n = 20..99
|
||||
Return t%i% ((o:=SubStr(n,2)) ? "-" o%o% : "")
|
||||
Return o%n% ; n = 0..19
|
||||
}
|
||||
PrettyNumber(n) { ; inserts thousands separators into a number string
|
||||
Return RegExReplace(n, "\B(?=((\d{3})+$))", ",")
|
||||
}
|
||||
3
Task/Four-is-magic/AutoHotkey/four-is-magic-2.ahk
Normal file
3
Task/Four-is-magic/AutoHotkey/four-is-magic-2.ahk
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
for i, num in StrSplit("7,54,235,8463,95723,485723,5472539,15750268,853956201,2736452849,94837286837,636478294710", ",")
|
||||
result .= Four_is_magic(num) "`n"
|
||||
MsgBox % result
|
||||
106
Task/Four-is-magic/C++/four-is-magic.cpp
Normal file
106
Task/Four-is-magic/C++/four-is-magic.cpp
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
#include <iostream>
|
||||
#include <string>
|
||||
#include <cctype>
|
||||
#include <cstdint>
|
||||
|
||||
typedef std::uint64_t integer;
|
||||
|
||||
const char* small[] = {
|
||||
"zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
|
||||
"nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
|
||||
"sixteen", "seventeen", "eighteen", "nineteen"
|
||||
};
|
||||
|
||||
const char* tens[] = {
|
||||
"twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"
|
||||
};
|
||||
|
||||
struct named_number {
|
||||
const char* name_;
|
||||
integer number_;
|
||||
};
|
||||
|
||||
const named_number named_numbers[] = {
|
||||
{ "hundred", 100 },
|
||||
{ "thousand", 1000 },
|
||||
{ "million", 1000000 },
|
||||
{ "billion", 1000000000 },
|
||||
{ "trillion", 1000000000000 },
|
||||
{ "quadrillion", 1000000000000000ULL },
|
||||
{ "quintillion", 1000000000000000000ULL }
|
||||
};
|
||||
|
||||
const named_number& get_named_number(integer n) {
|
||||
constexpr size_t names_len = std::size(named_numbers);
|
||||
for (size_t i = 0; i + 1 < names_len; ++i) {
|
||||
if (n < named_numbers[i + 1].number_)
|
||||
return named_numbers[i];
|
||||
}
|
||||
return named_numbers[names_len - 1];
|
||||
}
|
||||
|
||||
std::string cardinal(integer n) {
|
||||
std::string result;
|
||||
if (n < 20)
|
||||
result = small[n];
|
||||
else if (n < 100) {
|
||||
result = tens[n/10 - 2];
|
||||
if (n % 10 != 0) {
|
||||
result += "-";
|
||||
result += small[n % 10];
|
||||
}
|
||||
} else {
|
||||
const named_number& num = get_named_number(n);
|
||||
integer p = num.number_;
|
||||
result = cardinal(n/p);
|
||||
result += " ";
|
||||
result += num.name_;
|
||||
if (n % p != 0) {
|
||||
result += " ";
|
||||
result += cardinal(n % p);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
inline char uppercase(char ch) {
|
||||
return static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
|
||||
}
|
||||
|
||||
std::string magic(integer n) {
|
||||
std::string result;
|
||||
for (unsigned int i = 0; ; ++i) {
|
||||
std::string text(cardinal(n));
|
||||
if (i == 0)
|
||||
text[0] = uppercase(text[0]);
|
||||
result += text;
|
||||
if (n == 4) {
|
||||
result += " is magic.";
|
||||
break;
|
||||
}
|
||||
integer len = text.length();
|
||||
result += " is ";
|
||||
result += cardinal(len);
|
||||
result += ", ";
|
||||
n = len;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void test_magic(integer n) {
|
||||
std::cout << magic(n) << '\n';
|
||||
}
|
||||
|
||||
int main() {
|
||||
test_magic(5);
|
||||
test_magic(13);
|
||||
test_magic(78);
|
||||
test_magic(797);
|
||||
test_magic(2739);
|
||||
test_magic(4000);
|
||||
test_magic(7893);
|
||||
test_magic(93497412);
|
||||
test_magic(2673497412U);
|
||||
test_magic(10344658531277200972ULL);
|
||||
return 0;
|
||||
}
|
||||
98
Task/Four-is-magic/C/four-is-magic.c
Normal file
98
Task/Four-is-magic/C/four-is-magic.c
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <glib.h>
|
||||
|
||||
typedef struct named_number_tag {
|
||||
const char* name;
|
||||
uint64_t number;
|
||||
} named_number;
|
||||
|
||||
const named_number named_numbers[] = {
|
||||
{ "hundred", 100 },
|
||||
{ "thousand", 1000 },
|
||||
{ "million", 1000000 },
|
||||
{ "billion", 1000000000 },
|
||||
{ "trillion", 1000000000000 },
|
||||
{ "quadrillion", 1000000000000000ULL },
|
||||
{ "quintillion", 1000000000000000000ULL }
|
||||
};
|
||||
|
||||
const named_number* get_named_number(uint64_t n) {
|
||||
const size_t names_len = sizeof(named_numbers)/sizeof(named_number);
|
||||
for (size_t i = 0; i + 1 < names_len; ++i) {
|
||||
if (n < named_numbers[i + 1].number)
|
||||
return &named_numbers[i];
|
||||
}
|
||||
return &named_numbers[names_len - 1];
|
||||
}
|
||||
|
||||
size_t append_number_name(GString* str, uint64_t n) {
|
||||
static const char* small[] = {
|
||||
"zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
|
||||
"nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
|
||||
"sixteen", "seventeen", "eighteen", "nineteen"
|
||||
};
|
||||
static const char* tens[] = {
|
||||
"twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"
|
||||
};
|
||||
size_t len = str->len;
|
||||
if (n < 20) {
|
||||
g_string_append(str, small[n]);
|
||||
}
|
||||
else if (n < 100) {
|
||||
g_string_append(str, tens[n/10 - 2]);
|
||||
if (n % 10 != 0) {
|
||||
g_string_append_c(str, '-');
|
||||
g_string_append(str, small[n % 10]);
|
||||
}
|
||||
} else {
|
||||
const named_number* num = get_named_number(n);
|
||||
uint64_t p = num->number;
|
||||
append_number_name(str, n/p);
|
||||
g_string_append_c(str, ' ');
|
||||
g_string_append(str, num->name);
|
||||
if (n % p != 0) {
|
||||
g_string_append_c(str, ' ');
|
||||
append_number_name(str, n % p);
|
||||
}
|
||||
}
|
||||
return str->len - len;
|
||||
}
|
||||
|
||||
GString* magic(uint64_t n) {
|
||||
GString* str = g_string_new(NULL);
|
||||
for (unsigned int i = 0; ; ++i) {
|
||||
size_t count = append_number_name(str, n);
|
||||
if (i == 0)
|
||||
str->str[0] = g_ascii_toupper(str->str[0]);
|
||||
if (n == 4) {
|
||||
g_string_append(str, " is magic.");
|
||||
break;
|
||||
}
|
||||
g_string_append(str, " is ");
|
||||
append_number_name(str, count);
|
||||
g_string_append(str, ", ");
|
||||
n = count;
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
void test_magic(uint64_t n) {
|
||||
GString* str = magic(n);
|
||||
printf("%s\n", str->str);
|
||||
g_string_free(str, TRUE);
|
||||
}
|
||||
|
||||
int main() {
|
||||
test_magic(5);
|
||||
test_magic(13);
|
||||
test_magic(78);
|
||||
test_magic(797);
|
||||
test_magic(2739);
|
||||
test_magic(4000);
|
||||
test_magic(7893);
|
||||
test_magic(93497412);
|
||||
test_magic(2673497412U);
|
||||
test_magic(10344658531277200972ULL);
|
||||
return 0;
|
||||
}
|
||||
49
Task/Four-is-magic/Clojure/four-is-magic.clj
Normal file
49
Task/Four-is-magic/Clojure/four-is-magic.clj
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
(require '[clojure.edn :as edn])
|
||||
(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"
|
||||
12 "twelve" 13 "thirteen" 14 "fourteen" 15 "fifteen"
|
||||
16 "sixteen" 17 "seventeen" 18 "eighteen" 19 "nineteen"
|
||||
20 "twenty" 30 "thirty" 40 "forty" 50 "fifty" 60 "sixty"
|
||||
70 "seventy" 80 "eighty" 90 "ninety" 100 "hundred"
|
||||
|
||||
1000 "thousand" 1000000 "million" 1000000000 "billion"
|
||||
1000000000000 "trillion" 1000000000000000 "quadrillion"
|
||||
1000000000000000000 "quintillion" })
|
||||
|
||||
(def powers-of-10 (reverse (sort (filter #(clojure.string/ends-with? (str %) "00") (keys names)))))
|
||||
|
||||
(defn name-of [n]
|
||||
(let [p (first (filter #(>= n %) powers-of-10))]
|
||||
(cond
|
||||
(not (nil? p))
|
||||
(let [quotient (quot n p)
|
||||
remainder (rem n p)]
|
||||
(str (name-of quotient) " " (names p) (if (> remainder 0) (str " " (name-of remainder)))))
|
||||
|
||||
(and (nil? p) (> n 20))
|
||||
(let [remainder (rem n 10)
|
||||
tens (- n remainder)]
|
||||
(str (names tens) (if (> remainder 0) (str " " (name-of remainder)))))
|
||||
|
||||
true
|
||||
(names n))))
|
||||
|
||||
(defn four-is-magic
|
||||
([n] (four-is-magic n ""))
|
||||
([n prefix]
|
||||
(let [name ((if (empty? prefix) clojure.string/capitalize identity) (name-of n))
|
||||
new-prefix (str prefix (if (not (empty? prefix)) ", "))]
|
||||
(if (= n 4)
|
||||
(str new-prefix name " is magic.")
|
||||
(let [len (count name)]
|
||||
(four-is-magic len (str new-prefix name " is " (name-of len))))))))
|
||||
|
||||
(defn report [n]
|
||||
(println (str n ": " (four-is-magic n))))
|
||||
|
||||
(defn -main [& args]
|
||||
(doall (map (comp report edn/read-string) args)))
|
||||
|
||||
|
||||
(if (not= "repl" *command-line-args*)
|
||||
(apply -main *command-line-args*))
|
||||
7
Task/Four-is-magic/Common-Lisp/four-is-magic.lisp
Normal file
7
Task/Four-is-magic/Common-Lisp/four-is-magic.lisp
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
(defun integer-to-text (int)
|
||||
(format nil "~@(~A~)" (with-output-to-string (out)
|
||||
(loop for n = int then (length c)
|
||||
for c = (format nil "~R" n)
|
||||
while (/= n 4)
|
||||
do (format out "~A is ~R, " c (length c))
|
||||
finally (format out "four is magic.")))))
|
||||
109
Task/Four-is-magic/Delphi/four-is-magic.delphi
Normal file
109
Task/Four-is-magic/Delphi/four-is-magic.delphi
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
program Four_is_magic;
|
||||
|
||||
{$APPTYPE CONSOLE}
|
||||
|
||||
uses
|
||||
System.SysUtils;
|
||||
|
||||
// https://rosettacode.org/wiki/Number_names#Delphi
|
||||
const
|
||||
smallies: array[1..19] of string = ('one', 'two', 'three', 'four', 'five',
|
||||
'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen',
|
||||
'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen');
|
||||
tens: array[2..9] of string = ('twenty', 'thirty', 'forty', 'fifty', 'sixty',
|
||||
'seventy', 'eighty', 'ninety');
|
||||
|
||||
function domaxies(number: int64): string;
|
||||
const
|
||||
maxies: array[0..5] of string = (' thousand', ' million', ' billion',
|
||||
' trillion', ' quadrillion', ' quintillion');
|
||||
begin
|
||||
domaxies := '';
|
||||
if number >= 0 then
|
||||
domaxies := maxies[number];
|
||||
end;
|
||||
|
||||
function doHundreds(number: int64): string;
|
||||
begin
|
||||
Result := '';
|
||||
if number > 99 then
|
||||
begin
|
||||
Result := smallies[number div 100];
|
||||
Result := Result + ' hundred';
|
||||
number := number mod 100;
|
||||
if number > 0 then
|
||||
Result := Result + ' and ';
|
||||
end;
|
||||
if number >= 20 then
|
||||
begin
|
||||
Result := Result + tens[number div 10];
|
||||
number := number mod 10;
|
||||
if number > 0 then
|
||||
Result := Result + '-';
|
||||
end;
|
||||
if (0 < number) and (number < 20) then
|
||||
Result := Result + smallies[number];
|
||||
end;
|
||||
|
||||
function spell(number: int64): string;
|
||||
var
|
||||
scaleFactor: int64;
|
||||
maxieStart, h: int64;
|
||||
begin
|
||||
if number = 0 then
|
||||
exit('zero');
|
||||
|
||||
scaleFactor := 1000000000000000000;
|
||||
Result := '';
|
||||
if number < 0 then
|
||||
begin
|
||||
number := -number;
|
||||
Result := 'negative ';
|
||||
end;
|
||||
|
||||
maxieStart := 5;
|
||||
if number < 20 then
|
||||
exit(smallies[number]);
|
||||
while scaleFactor > 0 do
|
||||
begin
|
||||
if number > scaleFactor then
|
||||
begin
|
||||
h := number div scaleFactor;
|
||||
Result := Result + doHundreds(h) + domaxies(maxieStart);
|
||||
number := number mod scaleFactor;
|
||||
if number > 0 then
|
||||
Result := Result + ', ';
|
||||
end;
|
||||
scaleFactor := scaleFactor div 1000;
|
||||
dec(maxieStart);
|
||||
end;
|
||||
end;
|
||||
//****************************************************\\
|
||||
|
||||
const
|
||||
numbers: array of Int64 = [0, 4, 6, 11, 13, 75, 100, 337, -164, int64.MaxValue];
|
||||
|
||||
function fourIsMagic(n: int64): string;
|
||||
var
|
||||
s: string;
|
||||
begin
|
||||
s := spell(n);
|
||||
s[1] := upcase(s[1]);
|
||||
var t := s;
|
||||
|
||||
while n <> 4 do
|
||||
begin
|
||||
n := s.Length;
|
||||
s := spell(n);
|
||||
t := t + ' is ' + s + ', ' + s;
|
||||
end;
|
||||
t := t + ' is magic.';
|
||||
exit(t);
|
||||
end;
|
||||
|
||||
begin
|
||||
// writeln(spell(4));
|
||||
for var n in numbers do
|
||||
writeln(fourIsMagic(n));
|
||||
readln;
|
||||
end.
|
||||
8
Task/Four-is-magic/F-Sharp/four-is-magic-1.fs
Normal file
8
Task/Four-is-magic/F-Sharp/four-is-magic-1.fs
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
//Express an Integer in English Language. Nigel Galloway: September 19th., 2018
|
||||
let fN=[|[|"";"one";"two";"three";"four";"five";"six";"seven";"eight";"nine"|];
|
||||
[|"ten";"eleven";"twelve";"thirteen";"fourteen";"fifteen";"sixteen";"seventeen";"eighteen";"nineteen"|];
|
||||
[|"";"";"twenty";"thirty";"fourty";"fifty";"sixty";"seventy";"eighty";"ninety"|]|]
|
||||
let rec I2α α β=match α with |α when α<20 ->β+fN.[α/10].[α%10]
|
||||
|α when α<100 ->I2α (α%10) (β+fN.[2].[α/10]+if α%10>0 then " " else "")
|
||||
|α 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 " ")
|
||||
6
Task/Four-is-magic/F-Sharp/four-is-magic-2.fs
Normal file
6
Task/Four-is-magic/F-Sharp/four-is-magic-2.fs
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
let rec printI2α=function |0->printf "naught->"; printI2α 6
|
||||
|4->printfn "four is magic"
|
||||
|n when n<0->let g = I2α -n "minus " in printf "%s->" g; printI2α (g.Length)
|
||||
|n ->let g = I2α n "" in printf "%s->" g; printI2α (g.Length)
|
||||
let N=System.Random()
|
||||
List.init 25 (fun _->N.Next 999999) |> List.iter printI2α
|
||||
34
Task/Four-is-magic/Factor/four-is-magic.factor
Normal file
34
Task/Four-is-magic/Factor/four-is-magic.factor
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
USING: ascii formatting io kernel make math.text.english regexp
|
||||
sequences ;
|
||||
IN: rosetta-code.four-is-magic
|
||||
|
||||
! Strip " and " and "," from the output of Factor's number>text
|
||||
! word with a regular expression.
|
||||
: number>english ( n -- str )
|
||||
number>text R/ and |,/ "" re-replace ;
|
||||
|
||||
! Return the length of the input integer's text form.
|
||||
! e.g. 1 -> 3
|
||||
: next-len ( n -- m ) number>english length ;
|
||||
|
||||
! Given a starting integer, return the sequence of lengths
|
||||
! terminating with 4.
|
||||
! e.g. 1 -> { 1 3 5 4 }
|
||||
: len-chain ( n -- seq )
|
||||
[ [ dup 4 = ] [ dup , next-len ] until , ] { } make ;
|
||||
|
||||
! Convert a non-four number to its phrase form.
|
||||
! e.g. 6 -> "six is three, "
|
||||
: non-four ( n -- str )
|
||||
number>english dup length number>english
|
||||
"%s is %s, " sprintf ;
|
||||
|
||||
! Convert any number to its phrase form.
|
||||
! e.g. 4 -> "four is magic."
|
||||
: phrase ( n -- str )
|
||||
dup 4 = [ drop "four is magic." ] [ non-four ] if ;
|
||||
|
||||
: say-magic ( n -- )
|
||||
len-chain [ phrase ] map concat capitalize print ;
|
||||
|
||||
{ 1 4 -11 100 112719908181724 -612312 } [ say-magic ] each
|
||||
239
Task/Four-is-magic/Fortran/four-is-magic.f
Normal file
239
Task/Four-is-magic/Fortran/four-is-magic.f
Normal file
|
|
@ -0,0 +1,239 @@
|
|||
MODULE FOUR_IS_MAGIC
|
||||
IMPLICIT NONE
|
||||
CHARACTER(8), DIMENSION(20) :: SMALL_NUMS
|
||||
CHARACTER(7), DIMENSION(8) :: TENS
|
||||
CHARACTER(7) :: HUNDRED
|
||||
CHARACTER(8) :: THOUSAND
|
||||
CHARACTER(8) :: MILLION
|
||||
CHARACTER(8) :: BILLION
|
||||
CHARACTER(9) :: TRILLION
|
||||
CHARACTER(11) :: QUADRILLION
|
||||
CHARACTER(11) :: QUINTILLION
|
||||
CHARACTER(1) :: SEPARATOR
|
||||
CHARACTER(1) :: SPACE
|
||||
|
||||
|
||||
CONTAINS
|
||||
|
||||
SUBROUTINE INIT_ARRAYS
|
||||
|
||||
SMALL_NUMS(1) = "zero"
|
||||
SMALL_NUMS(2) = "one"
|
||||
SMALL_NUMS(3) = "two"
|
||||
SMALL_NUMS(4) = "three"
|
||||
SMALL_NUMS(5) = "four"
|
||||
SMALL_NUMS(6) = "five"
|
||||
SMALL_NUMS(7) = "six"
|
||||
SMALL_NUMS(8) = "seven"
|
||||
SMALL_NUMS(9) = "eight"
|
||||
SMALL_NUMS(10) = "nine"
|
||||
SMALL_NUMS(11) = "ten"
|
||||
SMALL_NUMS(12) = "eleven"
|
||||
SMALL_NUMS(13) = "twelve"
|
||||
SMALL_NUMS(14) = "thirteen"
|
||||
SMALL_NUMS(15) = "fourteen"
|
||||
SMALL_NUMS(16) = "fifteen"
|
||||
SMALL_NUMS(17) = "sixteen"
|
||||
SMALL_NUMS(18) = "seventeen"
|
||||
SMALL_NUMS(19) = "eighteen"
|
||||
SMALL_NUMS(20) = "nineteen"
|
||||
|
||||
TENS(1) = "twenty"
|
||||
TENS(2) = "thirty"
|
||||
TENS(3) = "forty"
|
||||
TENS(4) = "fifty"
|
||||
TENS(5) = "sixty"
|
||||
TENS(6) = "seventy"
|
||||
TENS(7) = "eight"
|
||||
TENS(8) = "ninety"
|
||||
|
||||
HUNDRED = "hundred"
|
||||
THOUSAND = "thousand"
|
||||
MILLION = "million"
|
||||
BILLION = "billion"
|
||||
TRILLION = "trillion"
|
||||
QUADRILLION = "quadrillion"
|
||||
QUINTILLION = "quintillion"
|
||||
SEPARATOR = "-"
|
||||
SPACE = " "
|
||||
|
||||
END SUBROUTINE INIT_ARRAYS
|
||||
|
||||
RECURSIVE FUNCTION STRING_REPRESENTATION(NUM) RESULT(NUM_AS_STR)
|
||||
INTEGER(16), INTENT(IN) :: NUM
|
||||
CHARACTER(1000) :: NUM_AS_STR
|
||||
INTEGER(16), DIMENSION(9) :: COMPONENTS
|
||||
|
||||
CALL INIT_ARRAYS()
|
||||
|
||||
COMPONENTS = GET_COMPONENTS(NUM)
|
||||
|
||||
NUM_AS_STR = TRIM(ADJUSTL(GET_SUBSET(COMPONENTS(9), QUINTILLION)))
|
||||
NUM_AS_STR = TRIM(NUM_AS_STR) // SPACE // TRIM(ADJUSTL(GET_SUBSET(COMPONENTS(8), QUADRILLION)))
|
||||
NUM_AS_STR = TRIM(NUM_AS_STR) // SPACE // TRIM(ADJUSTL(GET_SUBSET(COMPONENTS(7), TRILLION)))
|
||||
NUM_AS_STR = TRIM(NUM_AS_STR) // SPACE // TRIM(ADJUSTL(GET_SUBSET(COMPONENTS(6), BILLION)))
|
||||
NUM_AS_STR = TRIM(NUM_AS_STR) // SPACE // TRIM(ADJUSTL(GET_SUBSET(COMPONENTS(5), MILLION)))
|
||||
NUM_AS_STR = TRIM(NUM_AS_STR) // SPACE // TRIM(ADJUSTL(GET_SUBSET(COMPONENTS(4), THOUSAND)))
|
||||
NUM_AS_STR = TRIM(NUM_AS_STR) // SPACE // TRIM(ADJUSTL(GET_SUBSET(COMPONENTS(3), HUNDRED)))
|
||||
|
||||
|
||||
IF (COMPONENTS(2) .EQ. 1) THEN
|
||||
NUM_AS_STR = TRIM(ADJUSTL(NUM_AS_STR)) // SPACE // TRIM(ADJUSTL(SMALL_NUMS(10 + COMPONENTS(1) + 1)))
|
||||
ELSE
|
||||
|
||||
IF (COMPONENTS(1) .GT. 0) THEN
|
||||
IF (COMPONENTS(2) .GT. 0) THEN
|
||||
NUM_AS_STR = TRIM(ADJUSTL(NUM_AS_STR)) // SPACE // TRIM(ADJUSTL(TENS(COMPONENTS(2) - 1))) // SEPARATOR
|
||||
NUM_AS_STR = TRIM(ADJUSTL(NUM_AS_STR)) // TRIM(ADJUSTL(SMALL_NUMS(COMPONENTS(1) + 1)))
|
||||
ELSE
|
||||
NUM_AS_STR = TRIM(ADJUSTL(NUM_AS_STR)) // SPACE // TRIM(ADJUSTL(SMALL_NUMS(COMPONENTS(1) + 1)))
|
||||
ENDIF
|
||||
ELSE IF (COMPONENTS(2) .GT. 0) THEN
|
||||
NUM_AS_STR = TRIM(ADJUSTL(NUM_AS_STR)) // SPACE // TRIM(ADJUSTL(TENS(COMPONENTS(2) - 1)))
|
||||
ENDIF
|
||||
ENDIF
|
||||
|
||||
END FUNCTION STRING_REPRESENTATION
|
||||
|
||||
FUNCTION GET_COMPONENTS(NUM)
|
||||
INTEGER(16), INTENT(IN) :: NUM
|
||||
INTEGER(16), DIMENSION(9) :: GET_COMPONENTS
|
||||
INTEGER(16) :: I_UNITS
|
||||
INTEGER(16) :: I_TENS
|
||||
INTEGER(16) :: I_HUNDREDS
|
||||
INTEGER(16) :: I_THOUSANDS
|
||||
INTEGER(16) :: I_MILLIONS
|
||||
INTEGER(16) :: I_BILLIONS
|
||||
INTEGER(16) :: I_TRILLIONS
|
||||
INTEGER(16) :: I_QUADRILLIONS
|
||||
INTEGER(16) :: I_QUINTILLIONS
|
||||
REAL(16) DIVIDE_TEMP
|
||||
|
||||
I_UNITS = NUM
|
||||
|
||||
DIVIDE_TEMP = (I_UNITS - MOD(I_UNITS, 1000000000000000000))/1000000000000000000
|
||||
I_QUINTILLIONS = FLOOR(DIVIDE_TEMP)
|
||||
|
||||
IF (I_QUINTILLIONS .NE. 0) THEN
|
||||
I_UNITS = I_UNITS - I_QUINTILLIONS*1000000000000000000
|
||||
ENDIF
|
||||
|
||||
|
||||
DIVIDE_TEMP = (I_UNITS - MOD(I_UNITS, 1000000000000000))/1000000000000000
|
||||
I_QUADRILLIONS = FLOOR(DIVIDE_TEMP)
|
||||
|
||||
IF (I_QUADRILLIONS .NE. 0) THEN
|
||||
I_UNITS = I_UNITS - I_QUADRILLIONS*1000000000000000
|
||||
ENDIF
|
||||
|
||||
DIVIDE_TEMP = (I_UNITS - MOD(I_UNITS, 1000000000000))/1000000000000
|
||||
I_TRILLIONS = FLOOR(DIVIDE_TEMP)
|
||||
|
||||
IF (I_TRILLIONS .NE. 0) THEN
|
||||
I_UNITS = I_UNITS - I_TRILLIONS*1000000000000
|
||||
ENDIF
|
||||
|
||||
DIVIDE_TEMP = (I_UNITS - MOD(I_UNITS, 1000000000))/1000000000
|
||||
I_BILLIONS = FLOOR(DIVIDE_TEMP)
|
||||
|
||||
IF (I_BILLIONS .NE. 0) THEN
|
||||
I_UNITS = I_UNITS - I_BILLIONS*1000000000
|
||||
ENDIF
|
||||
|
||||
DIVIDE_TEMP = (I_UNITS - MOD(I_UNITS, 1000000))/1000000
|
||||
|
||||
I_MILLIONS = FLOOR(DIVIDE_TEMP)
|
||||
|
||||
IF (I_MILLIONS .NE. 0) THEN
|
||||
I_UNITS = I_UNITS - I_MILLIONS*1000000
|
||||
ENDIF
|
||||
|
||||
DIVIDE_TEMP = (I_UNITS - MOD(I_UNITS, 1000))/1000
|
||||
|
||||
I_THOUSANDS = FLOOR(DIVIDE_TEMP)
|
||||
|
||||
IF (I_THOUSANDS .NE. 0) THEN
|
||||
I_UNITS = I_UNITS - I_THOUSANDS*1000
|
||||
ENDIF
|
||||
|
||||
DIVIDE_TEMP = I_UNITS/1E2
|
||||
I_HUNDREDS = FLOOR(DIVIDE_TEMP)
|
||||
|
||||
IF (I_HUNDREDS .NE. 0) THEN
|
||||
I_UNITS = I_UNITS - I_HUNDREDS*1E2
|
||||
ENDIF
|
||||
|
||||
DIVIDE_TEMP = I_UNITS/10.
|
||||
I_TENS = FLOOR(DIVIDE_TEMP)
|
||||
|
||||
IF (I_TENS .NE. 0) THEN
|
||||
I_UNITS = I_UNITS - I_TENS*10
|
||||
ENDIF
|
||||
|
||||
GET_COMPONENTS(1) = I_UNITS
|
||||
GET_COMPONENTS(2) = I_TENS
|
||||
GET_COMPONENTS(3) = I_HUNDREDS
|
||||
GET_COMPONENTS(4) = I_THOUSANDS
|
||||
GET_COMPONENTS(5) = I_MILLIONS
|
||||
GET_COMPONENTS(6) = I_BILLIONS
|
||||
GET_COMPONENTS(7) = I_TRILLIONS
|
||||
GET_COMPONENTS(8) = I_QUADRILLIONS
|
||||
GET_COMPONENTS(9) = I_QUINTILLIONS
|
||||
|
||||
END FUNCTION GET_COMPONENTS
|
||||
|
||||
FUNCTION GET_SUBSET(COUNTER, LABEL) RESULT(OUT_STR)
|
||||
CHARACTER(*), INTENT(IN) :: LABEL
|
||||
INTEGER(16), INTENT(IN) :: COUNTER
|
||||
CHARACTER(100) :: OUT_STR
|
||||
|
||||
OUT_STR = ""
|
||||
|
||||
IF (COUNTER .GT. 0) THEN
|
||||
IF (COUNTER .LT. 20) THEN
|
||||
OUT_STR = SPACE // TRIM(ADJUSTL(SMALL_NUMS(COUNTER + 1)))
|
||||
ELSE
|
||||
OUT_STR = SPACE // TRIM(ADJUSTL(STRING_REPRESENTATION(COUNTER)))
|
||||
ENDIF
|
||||
OUT_STR = TRIM(ADJUSTL(OUT_STR)) // SPACE // TRIM(LABEL)
|
||||
ENDIF
|
||||
|
||||
END FUNCTION GET_SUBSET
|
||||
|
||||
|
||||
SUBROUTINE FIND_MAGIC(NUM)
|
||||
INTEGER(16), INTENT(IN) :: NUM
|
||||
INTEGER(16) :: CURRENT, LEN_SIZE
|
||||
CHARACTER(1000) :: CURRENT_STR, CURRENT_STR_LEN
|
||||
CHARACTER(1000) :: OUT_STR
|
||||
|
||||
CURRENT = NUM
|
||||
OUT_STR = ""
|
||||
|
||||
DO WHILE (CURRENT .NE. 4)
|
||||
CURRENT_STR = STRING_REPRESENTATION(CURRENT)
|
||||
LEN_SIZE = LEN_TRIM(ADJUSTL(CURRENT_STR))
|
||||
CURRENT_STR_LEN = STRING_REPRESENTATION(LEN_SIZE)
|
||||
OUT_STR = TRIM(ADJUSTL(OUT_STR)) // SPACE // TRIM(ADJUSTL(CURRENT_STR))
|
||||
OUT_STR = TRIM(ADJUSTL(OUT_STR)) // " is " // TRIM(ADJUSTL(CURRENT_STR_LEN)) // ","
|
||||
CURRENT = LEN_SIZE
|
||||
ENDDO
|
||||
|
||||
WRITE(*,*) TRIM(ADJUSTL(OUT_STR)) // SPACE // "four is magic."
|
||||
END SUBROUTINE FIND_MAGIC
|
||||
|
||||
|
||||
END MODULE FOUR_IS_MAGIC
|
||||
|
||||
PROGRAM TEST_NUM_NAME
|
||||
USE FOUR_IS_MAGIC
|
||||
IMPLICIT NONE
|
||||
|
||||
INTEGER(2) I
|
||||
INTEGER(16), DIMENSION(10) :: TEST_NUMS = (/5, 13, 78, 797, 2739, 4000, 7893, 93497412, 2673497412, 10344658531277200972/)
|
||||
CHARACTER(1000) :: NUM_NAME
|
||||
|
||||
DO I=1, SIZE(TEST_NUMS)
|
||||
CALL FIND_MAGIC(TEST_NUMS(I))
|
||||
ENDDO
|
||||
END PROGRAM
|
||||
86
Task/Four-is-magic/FreeBASIC/four-is-magic.basic
Normal file
86
Task/Four-is-magic/FreeBASIC/four-is-magic.basic
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
#define floor(x) ((x*2.0-0.5) Shr 1)
|
||||
|
||||
Dim Shared veintes(1 To 20) As String*9 => _
|
||||
{"zero", "one", "two", "three", "four", "five", "six", _
|
||||
"seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", _
|
||||
"fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"}
|
||||
|
||||
Dim Shared decenas(1 To 8) As String*7 => _
|
||||
{"twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"}
|
||||
|
||||
Type myorder
|
||||
var1 As Double
|
||||
var2 As String*8
|
||||
End Type
|
||||
Dim Shared orders(1 To 4) As myorder => _
|
||||
{(10^12,"trillion"), (10^9,"billion"), (10^6,"million"), (10^3,"thousand")}
|
||||
|
||||
Function centenas(n As Integer) As String
|
||||
If n < 20 Then
|
||||
Return veintes((n Mod 20)+1)
|
||||
Elseif (n Mod 10) = 0 Then
|
||||
Return decenas((floor(n/10) Mod 10)-1)
|
||||
End If
|
||||
Return decenas((floor(n/10) Mod 10)-1) & "-" & veintes((n Mod 10)+1)
|
||||
End Function
|
||||
|
||||
Function miles(n As Integer) As String
|
||||
If n < 100 Then
|
||||
Return centenas(n)
|
||||
Elseif (n Mod 100) = 0 Then
|
||||
Return veintes((floor(n/100) Mod 20)+1) & " centenas"
|
||||
End If
|
||||
Return veintes((floor(n/100) Mod 20)+1) & " centenas " & centenas(n Mod 100)
|
||||
End Function
|
||||
|
||||
Function triplet(n As Integer) As String
|
||||
Dim As Integer order, high, low
|
||||
Dim As String nombre, res = ""
|
||||
For i As Integer = 1 To Ubound(orders)
|
||||
order = orders(i).var1
|
||||
nombre = orders(i).var2
|
||||
high = floor(n/order)
|
||||
low = (n Mod order)
|
||||
If high <> 0 Then res &= miles(high) & " " & nombre
|
||||
n = low
|
||||
If low = 0 Then Exit For : End If
|
||||
If Len(res) And high <> 0 Then res &= " "
|
||||
Next i
|
||||
If n <> 0 Or res="" Then
|
||||
res &= miles(floor(n))
|
||||
End If
|
||||
Return res
|
||||
End Function
|
||||
|
||||
Function deletrear(n As Integer) As String
|
||||
Dim As String res = ""
|
||||
If n < 0 Then
|
||||
res = "negative "
|
||||
n = -n
|
||||
End If
|
||||
res &= triplet(n)
|
||||
|
||||
Return res
|
||||
End Function
|
||||
|
||||
Function fourIsMagic(n As Integer) As String
|
||||
Dim As String s = deletrear(n)
|
||||
s = Mid(Ucase(s), 1, 1) & Mid(s, 2, Len(s))
|
||||
Dim As String t = s
|
||||
While n <> 4
|
||||
n = Len(s)
|
||||
s = deletrear(n)
|
||||
t &= " is " & s & ", " & s
|
||||
Wend
|
||||
t &= " is magic."
|
||||
Return t
|
||||
End Function
|
||||
|
||||
Dim As Longint tests(1 To 21) = _
|
||||
{-21, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, _
|
||||
34, 123, 456, 1024, 1234, 12345, 123456, 1010101}
|
||||
|
||||
For i As Integer = 1 To Ubound(tests)
|
||||
Print Using "#######: &"; tests(i); fourIsMagic(tests(i))
|
||||
Next i
|
||||
Sleep
|
||||
80
Task/Four-is-magic/Go/four-is-magic.go
Normal file
80
Task/Four-is-magic/Go/four-is-magic.go
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func main() {
|
||||
for _, n := range [...]int64{
|
||||
0, 4, 6, 11, 13, 75, 100, 337, -164,
|
||||
math.MaxInt64,
|
||||
} {
|
||||
fmt.Println(fourIsMagic(n))
|
||||
}
|
||||
}
|
||||
|
||||
func fourIsMagic(n int64) string {
|
||||
s := say(n)
|
||||
s = strings.ToUpper(s[:1]) + s[1:]
|
||||
t := s
|
||||
for n != 4 {
|
||||
n = int64(len(s))
|
||||
s = say(n)
|
||||
t += " is " + s + ", " + s
|
||||
}
|
||||
t += " is magic."
|
||||
return t
|
||||
}
|
||||
|
||||
// Following is from https://rosettacode.org/wiki/Number_names#Go
|
||||
|
||||
var small = [...]string{"zero", "one", "two", "three", "four", "five", "six",
|
||||
"seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen",
|
||||
"fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"}
|
||||
var tens = [...]string{"", "", "twenty", "thirty", "forty",
|
||||
"fifty", "sixty", "seventy", "eighty", "ninety"}
|
||||
var illions = [...]string{"", " thousand", " million", " billion",
|
||||
" trillion", " quadrillion", " quintillion"}
|
||||
|
||||
func say(n int64) string {
|
||||
var t string
|
||||
if n < 0 {
|
||||
t = "negative "
|
||||
// Note, for math.MinInt64 this leaves n negative.
|
||||
n = -n
|
||||
}
|
||||
switch {
|
||||
case n < 20:
|
||||
t += small[n]
|
||||
case n < 100:
|
||||
t += tens[n/10]
|
||||
s := n % 10
|
||||
if s > 0 {
|
||||
t += "-" + small[s]
|
||||
}
|
||||
case n < 1000:
|
||||
t += small[n/100] + " hundred"
|
||||
s := n % 100
|
||||
if s > 0 {
|
||||
t += " " + say(s)
|
||||
}
|
||||
default:
|
||||
// work right-to-left
|
||||
sx := ""
|
||||
for i := 0; n > 0; i++ {
|
||||
p := n % 1000
|
||||
n /= 1000
|
||||
if p > 0 {
|
||||
ix := say(p) + illions[i]
|
||||
if sx != "" {
|
||||
ix += " " + sx
|
||||
}
|
||||
sx = ix
|
||||
}
|
||||
}
|
||||
t += sx
|
||||
}
|
||||
return t
|
||||
}
|
||||
60
Task/Four-is-magic/Haskell/four-is-magic.hs
Normal file
60
Task/Four-is-magic/Haskell/four-is-magic.hs
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
module Main where
|
||||
|
||||
import Data.List (find)
|
||||
import Data.Char (toUpper)
|
||||
|
||||
firstNums :: [String]
|
||||
firstNums =
|
||||
[ "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
|
||||
"eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
|
||||
]
|
||||
|
||||
tens :: [String]
|
||||
tens = ["twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
|
||||
|
||||
biggerNumbers :: [(Int, String)]
|
||||
biggerNumbers =
|
||||
[(100, "hundred"), (1000, "thousand"), (1000000, "million"), (1000000000, "billion"), (1000000000000, "trillion")]
|
||||
|
||||
cardinal :: Int -> String
|
||||
cardinal n
|
||||
| n' < 20 =
|
||||
negText ++ firstNums !! n'
|
||||
| n' < 100 =
|
||||
negText ++ tens !! (n' `div` 10 - 2) ++ if n' `mod` 10 /= 0 then "-" ++ firstNums !! (n' `mod` 10) else ""
|
||||
| otherwise =
|
||||
let (num, name) =
|
||||
maybe
|
||||
(last biggerNumbers)
|
||||
fst
|
||||
(find (\((num_, _), (num_', _)) -> n' < num_') (zip biggerNumbers (tail biggerNumbers)))
|
||||
smallerNum = cardinal (n' `div` num)
|
||||
in negText ++ smallerNum ++ " " ++ name ++ if n' `mod` num /= 0 then " " ++ cardinal (n' `mod` num) else ""
|
||||
where
|
||||
n' = abs n
|
||||
negText = if n < 0 then "negative " else ""
|
||||
|
||||
capitalized :: String -> String
|
||||
capitalized (x : xs) = toUpper x : xs
|
||||
capitalized [] = []
|
||||
|
||||
magic :: Int -> String
|
||||
magic =
|
||||
go True
|
||||
where
|
||||
go first num =
|
||||
let cardiNum = cardinal num
|
||||
in (if first then capitalized else id) cardiNum ++ " is "
|
||||
++ if num == 4
|
||||
then "magic."
|
||||
else cardinal (length cardiNum) ++ ", " ++ go False (length cardiNum)
|
||||
|
||||
main :: IO ()
|
||||
main = do
|
||||
putStrLn $ magic 3
|
||||
putStrLn $ magic 15
|
||||
putStrLn $ magic 4
|
||||
putStrLn $ magic 10
|
||||
putStrLn $ magic 20
|
||||
putStrLn $ magic (-13)
|
||||
putStrLn $ magic 999999
|
||||
43
Task/Four-is-magic/J/four-is-magic.j
Normal file
43
Task/Four-is-magic/J/four-is-magic.j
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
names =. 'one';'two';'three';'four';'five';'six';'seven';'eight';'nine';'ten';'eleven';'twelve';'thirteen';'fourteen';'fifteen';'sixteen';'seventeen';'eighteen';'nineteen'
|
||||
|
||||
tens =. '';'twenty';'thirty';'forty';'fifty';'sixty';'seventy';'eighty';'ninety'
|
||||
|
||||
NB. selects the xth element from list y
|
||||
lookup =: >@{:@{.
|
||||
|
||||
NB. string formatting
|
||||
addspace =: ((' '"_, ]) ` ]) @. (<&0 @ {: @ $)
|
||||
|
||||
NB. numbers in range 1 to 19
|
||||
s1 =: lookup&names
|
||||
|
||||
NB. numbers in range 20 to 99
|
||||
s2d=: (lookup&tens @ <. @ %&10) , addspace @ (s1 @ (10&|))
|
||||
|
||||
NB. numbers in range 100 to 999
|
||||
s3d =: s1 @ (<.@%&100), ' hundred', addspace @ s2d @ (100&|)
|
||||
|
||||
NB. numbers in range 1 to 999
|
||||
s123d =: s1 ` s2d ` s3d @. (>& 19 + >&99)
|
||||
|
||||
NB. numbers in range 1000 to 999999
|
||||
s456d =: (s123d @<.@%&1000), ' thousand', addspace @ s123d @ (1000&|)
|
||||
|
||||
NB. stringify numbers in range 1 to 999999
|
||||
stringify =: s123d ` s456d @. (>&999)
|
||||
|
||||
NB. takes an int and returns an int of the length of the string of the input
|
||||
lengthify =: {: @ $ @ stringify
|
||||
|
||||
NB. determines the string that should go after ' is '
|
||||
what =: ((stringify @ lengthify), (', '"_)) ` ('magic'"_) @. (=&4)
|
||||
|
||||
runonce =: stringify , ' is ', what
|
||||
|
||||
run =: runonce, ((run @ lengthify) ` (''"_) @. (=&4))
|
||||
|
||||
doall =: run"0
|
||||
|
||||
inputs =: 4 8 16 25 89 365 2586 25865 369854
|
||||
|
||||
doall inputs
|
||||
73
Task/Four-is-magic/Java/four-is-magic.java
Normal file
73
Task/Four-is-magic/Java/four-is-magic.java
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
public class FourIsMagic {
|
||||
|
||||
public static void main(String[] args) {
|
||||
for ( long n : new long[] {6, 60, 89, 300, 670, 2000, 2467, 20000, 24500,200000, 230000, 246571, 2300000, 2465712, 20000000, 24657123, 230000000, 245000000, -246570000, 123456789712345l, 8777777777777777777L, Long.MAX_VALUE}) {
|
||||
String magic = fourIsMagic(n);
|
||||
System.out.printf("%d = %s%n", n, toSentence(magic));
|
||||
}
|
||||
}
|
||||
|
||||
private static final String toSentence(String s) {
|
||||
return s.substring(0,1).toUpperCase() + s.substring(1) + ".";
|
||||
}
|
||||
|
||||
private static final String[] nums = new String[] {
|
||||
"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
|
||||
"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
|
||||
};
|
||||
|
||||
private static final String[] tens = new String[] {"zero", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
|
||||
|
||||
private static final String fourIsMagic(long n) {
|
||||
if ( n == 4 ) {
|
||||
return numToString(n) + " is magic";
|
||||
}
|
||||
String result = numToString(n);
|
||||
return result + " is " + numToString(result.length()) + ", " + fourIsMagic(result.length());
|
||||
}
|
||||
|
||||
private static final String numToString(long n) {
|
||||
if ( n < 0 ) {
|
||||
return "negative " + numToString(-n);
|
||||
}
|
||||
int index = (int) n;
|
||||
if ( n <= 19 ) {
|
||||
return nums[index];
|
||||
}
|
||||
if ( n <= 99 ) {
|
||||
return tens[index/10] + (n % 10 > 0 ? " " + numToString(n % 10) : "");
|
||||
}
|
||||
String label = null;
|
||||
long factor = 0;
|
||||
if ( n <= 999 ) {
|
||||
label = "hundred";
|
||||
factor = 100;
|
||||
}
|
||||
else if ( n <= 999999) {
|
||||
label = "thousand";
|
||||
factor = 1000;
|
||||
}
|
||||
else if ( n <= 999999999) {
|
||||
label = "million";
|
||||
factor = 1000000;
|
||||
}
|
||||
else if ( n <= 999999999999L) {
|
||||
label = "billion";
|
||||
factor = 1000000000;
|
||||
}
|
||||
else if ( n <= 999999999999999L) {
|
||||
label = "trillion";
|
||||
factor = 1000000000000L;
|
||||
}
|
||||
else if ( n <= 999999999999999999L) {
|
||||
label = "quadrillion";
|
||||
factor = 1000000000000000L;
|
||||
}
|
||||
else {
|
||||
label = "quintillion";
|
||||
factor = 1000000000000000000L;
|
||||
}
|
||||
return numToString(n / factor) + " " + label + (n % factor > 0 ? " " + numToString(n % factor ) : "");
|
||||
}
|
||||
|
||||
}
|
||||
1
Task/Four-is-magic/JavaScript/four-is-magic-1.js
Normal file
1
Task/Four-is-magic/JavaScript/four-is-magic-1.js
Normal file
|
|
@ -0,0 +1 @@
|
|||
Object.getOwnPropertyNames(this).includes('BigInt')
|
||||
181
Task/Four-is-magic/JavaScript/four-is-magic-2.js
Normal file
181
Task/Four-is-magic/JavaScript/four-is-magic-2.js
Normal file
|
|
@ -0,0 +1,181 @@
|
|||
const reverseOrderedNumberToTextMap = (function () {
|
||||
const rawNumberToTextMapping = { // Ported over from the Python solution.
|
||||
[1n]: "one",
|
||||
[2n]: "two",
|
||||
[3n]: "three",
|
||||
[4n]: "four",
|
||||
[5n]: "five",
|
||||
[6n]: "six",
|
||||
[7n]: "seven",
|
||||
[8n]: "eight",
|
||||
[9n]: "nine",
|
||||
[10n]: "ten",
|
||||
[11n]: "eleven",
|
||||
[12n]: "twelve",
|
||||
[13n]: "thirteen",
|
||||
[14n]: "fourteen",
|
||||
[15n]: "fifteen",
|
||||
[16n]: "sixteen",
|
||||
[17n]: "seventeen",
|
||||
[18n]: "eighteen",
|
||||
[19n]: "nineteen",
|
||||
[20n]: "twenty",
|
||||
[30n]: "thirty",
|
||||
[40n]: "forty",
|
||||
[50n]: "fifty",
|
||||
[60n]: "sixty",
|
||||
[70n]: "seventy",
|
||||
[80n]: "eighty",
|
||||
[90n]: "ninety",
|
||||
[100n]: "hundred",
|
||||
[1000n]: "thousand",
|
||||
[10n ** 6n]: "million",
|
||||
[10n ** 9n]: "billion",
|
||||
[10n ** 12n]: "trillion",
|
||||
[10n ** 15n]: "quadrillion",
|
||||
[10n ** 18n]: "quintillion",
|
||||
[10n ** 21n]: "sextillion",
|
||||
[10n ** 24n]: "septillion",
|
||||
[10n ** 27n]: "octillion",
|
||||
[10n ** 30n]: "nonillion",
|
||||
[10n ** 33n]: "decillion",
|
||||
[10n ** 36n]: "undecillion",
|
||||
[10n ** 39n]: "duodecillion",
|
||||
[10n ** 42n]: "tredecillion",
|
||||
[10n ** 45n]: "quattuordecillion",
|
||||
[10n ** 48n]: "quinquadecillion",
|
||||
[10n ** 51n]: "sedecillion",
|
||||
[10n ** 54n]: "septendecillion",
|
||||
[10n ** 57n]: "octodecillion",
|
||||
[10n ** 60n]: "novendecillion",
|
||||
[10n ** 63n]: "vigintillion",
|
||||
[10n ** 66n]: "unvigintillion",
|
||||
[10n ** 69n]: "duovigintillion",
|
||||
[10n ** 72n]: "tresvigintillion",
|
||||
[10n ** 75n]: "quattuorvigintillion",
|
||||
[10n ** 78n]: "quinquavigintillion",
|
||||
[10n ** 81n]: "sesvigintillion",
|
||||
[10n ** 84n]: "septemvigintillion",
|
||||
[10n ** 87n]: "octovigintillion",
|
||||
[10n ** 90n]: "novemvigintillion",
|
||||
[10n ** 93n]: "trigintillion",
|
||||
[10n ** 96n]: "untrigintillion",
|
||||
[10n ** 99n]: "duotrigintillion",
|
||||
[10n ** 102n]: "trestrigintillion",
|
||||
[10n ** 105n]: "quattuortrigintillion",
|
||||
[10n ** 108n]: "quinquatrigintillion",
|
||||
[10n ** 111n]: "sestrigintillion",
|
||||
[10n ** 114n]: "septentrigintillion",
|
||||
[10n ** 117n]: "octotrigintillion",
|
||||
[10n ** 120n]: "noventrigintillion",
|
||||
[10n ** 123n]: "quadragintillion",
|
||||
[10n ** 153n]: "quinquagintillion",
|
||||
[10n ** 183n]: "sexagintillion",
|
||||
[10n ** 213n]: "septuagintillion",
|
||||
[10n ** 243n]: "octogintillion",
|
||||
[10n ** 273n]: "nonagintillion",
|
||||
[10n ** 303n]: "centillion",
|
||||
[10n ** 306n]: "uncentillion",
|
||||
[10n ** 309n]: "duocentillion",
|
||||
[10n ** 312n]: "trescentillion",
|
||||
[10n ** 333n]: "decicentillion",
|
||||
[10n ** 336n]: "undecicentillion",
|
||||
[10n ** 363n]: "viginticentillion",
|
||||
[10n ** 366n]: "unviginticentillion",
|
||||
[10n ** 393n]: "trigintacentillion",
|
||||
[10n ** 423n]: "quadragintacentillion",
|
||||
[10n ** 453n]: "quinquagintacentillion",
|
||||
[10n ** 483n]: "sexagintacentillion",
|
||||
[10n ** 513n]: "septuagintacentillion",
|
||||
[10n ** 543n]: "octogintacentillion",
|
||||
[10n ** 573n]: "nonagintacentillion",
|
||||
[10n ** 603n]: "ducentillion",
|
||||
[10n ** 903n]: "trecentillion",
|
||||
[10n ** 1203n]: "quadringentillion",
|
||||
[10n ** 1503n]: "quingentillion",
|
||||
[10n ** 1803n]: "sescentillion",
|
||||
[10n ** 2103n]: "septingentillion",
|
||||
[10n ** 2403n]: "octingentillion",
|
||||
[10n ** 2703n]: "nongentillion",
|
||||
[10n ** 3003n]: "millinillion"
|
||||
};
|
||||
|
||||
return new Map(Object.entries(rawNumberToTextMapping)
|
||||
.sort((a, b) => BigInt(a[0]) > BigInt(b[0]) ? -1 : 1)
|
||||
.map(numberAndText => [BigInt(numberAndText[0]), numberAndText[1]]));
|
||||
})();
|
||||
|
||||
|
||||
function getCardinalRepresentation(number)
|
||||
{
|
||||
if (number == 0n)
|
||||
{
|
||||
return "zero";
|
||||
}
|
||||
|
||||
function* generateCardinalRepresentationTokens(number)
|
||||
{
|
||||
if (number <= 0n)
|
||||
{
|
||||
yield "negative";
|
||||
number *= -1n;
|
||||
}
|
||||
|
||||
for (const [currentEntryNumber, currentEntryText] of reverseOrderedNumberToTextMap.entries())
|
||||
{
|
||||
if (number >= currentEntryNumber)
|
||||
{
|
||||
if (currentEntryNumber >= 100n)
|
||||
{
|
||||
yield* generateCardinalRepresentationTokens(number / currentEntryNumber);
|
||||
}
|
||||
|
||||
yield currentEntryText;
|
||||
number -= currentEntryNumber;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return [...generateCardinalRepresentationTokens(number)].join(" ");
|
||||
}
|
||||
|
||||
function* generateFourIsMagicParts(number)
|
||||
{
|
||||
if (typeof number != "bigint")
|
||||
{
|
||||
number = BigInt(number);
|
||||
}
|
||||
|
||||
if (number == 4n)
|
||||
{
|
||||
yield "four is magic";
|
||||
}
|
||||
else
|
||||
{
|
||||
const cardinalRepresentation = getCardinalRepresentation(number);
|
||||
yield `${cardinalRepresentation} is ${getCardinalRepresentation(BigInt(cardinalRepresentation.length))}`;
|
||||
yield* generateFourIsMagicParts(cardinalRepresentation.length);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function capitalizeFirstLetter(str)
|
||||
{
|
||||
return str.replace(/^([a-z])/, chr => chr.toUpperCase());
|
||||
}
|
||||
|
||||
function fourIsMagic(number)
|
||||
{
|
||||
return capitalizeFirstLetter(`${[...generateFourIsMagicParts(number)].join(", ")}.`);
|
||||
}
|
||||
|
||||
[
|
||||
0,
|
||||
-150,
|
||||
210,
|
||||
10n ** 2703n + 1225n,
|
||||
4,
|
||||
-4,
|
||||
10n ** 3003n + 42n
|
||||
].map(fourIsMagic).join("\n\n");
|
||||
54
Task/Four-is-magic/Jq/four-is-magic.jq
Normal file
54
Task/Four-is-magic/Jq/four-is-magic.jq
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
def small: ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven",
|
||||
"twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"];
|
||||
|
||||
def tens: ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];
|
||||
|
||||
def illions: ["", " thousand", " million", " billion"," trillion", " quadrillion", " quintillion"];
|
||||
|
||||
def say:
|
||||
{n: ., t: ""}
|
||||
| if .n < 0
|
||||
then .t = "negative " | .n = -.n
|
||||
else . end
|
||||
| if .n < 20
|
||||
then .t += small[.n]
|
||||
elif .n < 100
|
||||
then .t += tens[(.n/10)|floor]
|
||||
| .s = .n % 10
|
||||
| if (.s > 0) then .t += "-" + small[.s] else . end
|
||||
elif .n < 1000
|
||||
then .t += small[(.n/100)|floor] + " hundred"
|
||||
| .s = .n % 100
|
||||
| if .s > 0 then .t += " " + (.s|say) else . end
|
||||
else .sx = ""
|
||||
| .i = 0
|
||||
| until(.n == 0;
|
||||
.p = .n % 1000
|
||||
| .n = (.n / 1000 |floor)
|
||||
| if (.p > 0)
|
||||
then .ix = (.p|say) + illions[.i]
|
||||
| if (.sx != "") then .ix += " " + .sx else . end
|
||||
| .sx = .ix
|
||||
else .
|
||||
end
|
||||
| .i += 1 )
|
||||
| .t += .sx
|
||||
end
|
||||
| .t;
|
||||
|
||||
def capitalize:
|
||||
.[:1] as $x
|
||||
| ($x | ascii_upcase) as $X
|
||||
| if $x == $X then . else $X + .[1:] end;
|
||||
|
||||
def fourIsMagic:
|
||||
{n: ., s: (say | capitalize)}
|
||||
| .t = .s
|
||||
| until(.n == 4;
|
||||
.n = (.s|length)
|
||||
| .s = (.n | say)
|
||||
| .t += " is " + .s + ", " + .s )
|
||||
| .t + " is magic." ;
|
||||
|
||||
(0, 4, 6, 11, 13, 75, 100, 337, -164, 9007199254740991)
|
||||
| fourIsMagic
|
||||
101
Task/Four-is-magic/Julia/four-is-magic.julia
Normal file
101
Task/Four-is-magic/Julia/four-is-magic.julia
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
# The num2text routines are from the "Number names" task, updated for Julia 1.0
|
||||
|
||||
const stext = ["one", "two", "three", "four", "five",
|
||||
"six", "seven", "eight", "nine"]
|
||||
const teentext = ["eleven", "twelve", "thirteen", "fourteen",
|
||||
"fifteen", "sixteen", "seventeen",
|
||||
"eighteen", "nineteen"]
|
||||
const tenstext = ["ten", "twenty", "thirty", "forty", "fifty",
|
||||
"sixty", "seventy", "eighty", "ninety"]
|
||||
const ordstext = ["million", "billion", "trillion",
|
||||
"quadrillion", "quintillion", "sextillion",
|
||||
"septillion", "octillion", "nonillion",
|
||||
"decillion", "undecillion", "duodecillion",
|
||||
"tredecillion", "quattuordecillion", "quindecillion",
|
||||
"sexdecillion", "septendecillion", "octodecillion",
|
||||
"novemdecillion", "vigintillion"]
|
||||
|
||||
function normalize_digits!(a)
|
||||
while 0 < length(a) && a[end] == 0
|
||||
pop!(a)
|
||||
end
|
||||
return length(a)
|
||||
end
|
||||
|
||||
function digits2text!(d, use_short_scale=true)
|
||||
ndig = normalize_digits!(d)
|
||||
0 < ndig || return ""
|
||||
if ndig < 7
|
||||
s = ""
|
||||
if 3 < ndig
|
||||
t = digits2text!(d[1:3])
|
||||
s = digits2text!(d[4:end])*" thousand"
|
||||
0 < length(t) || return s
|
||||
if occursin("and", t)
|
||||
return s*" "*t
|
||||
else
|
||||
return s*" and "*t
|
||||
end
|
||||
end
|
||||
if ndig == 3
|
||||
s *= stext[pop!(d)]*" hundred"
|
||||
ndig = normalize_digits!(d)
|
||||
0 < ndig || return s
|
||||
s *= " and "
|
||||
end
|
||||
1 < ndig || return s*stext[pop!(d)]
|
||||
j, i = d
|
||||
j != 0 || return s*tenstext[i]
|
||||
i != 1 || return s*teentext[j]
|
||||
return s*tenstext[i]*"-"*stext[j]
|
||||
end
|
||||
s = digits2text!(d[1:6])
|
||||
d = d[7:end]
|
||||
dgrp = use_short_scale ? 3 : 6
|
||||
ord = 0
|
||||
while(dgrp < length(d))
|
||||
ord += 1
|
||||
t = digits2text!(d[1:dgrp])
|
||||
d = d[(dgrp+1):end]
|
||||
0 < length(t) || continue
|
||||
t = t*" "*ordstext[ord]
|
||||
if length(s) == 0
|
||||
s = t
|
||||
else
|
||||
s = t*" "*s
|
||||
end
|
||||
end
|
||||
ord += 1
|
||||
t = digits2text!(d)*" "*ordstext[ord]
|
||||
0 < length(s) || return t
|
||||
return t*" "*s
|
||||
end
|
||||
|
||||
function num2text(n, use_short_scale=true)
|
||||
-1 < n || return "minus "*num2text(-n, use_short_scale)
|
||||
0 < n || return "zero"
|
||||
toobig = use_short_scale ? big(10)^66 : big(10)^126
|
||||
n < toobig || return "too big to say"
|
||||
return digits2text!(digits(n, base=10), use_short_scale)
|
||||
end
|
||||
|
||||
|
||||
function magic(n)
|
||||
str = uppercasefirst(num2text(n))
|
||||
n = length(str)
|
||||
while true
|
||||
numtext = num2text(n)
|
||||
str *= " is " * numtext
|
||||
if numtext == "four"
|
||||
break
|
||||
end
|
||||
str *= ", " * numtext
|
||||
n = length(numtext)
|
||||
end
|
||||
println(str[1:7] == "Four is" ? "Four is magic." : "$str, four is magic.")
|
||||
end
|
||||
|
||||
|
||||
for n in [0, 4, 6, 11, 13, 75, 337, -164, 9_876_543_209]
|
||||
magic(n)
|
||||
end
|
||||
108
Task/Four-is-magic/Kotlin/four-is-magic.kotlin
Normal file
108
Task/Four-is-magic/Kotlin/four-is-magic.kotlin
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
// version 1.1.4-3
|
||||
|
||||
val names = mapOf(
|
||||
1 to "one",
|
||||
2 to "two",
|
||||
3 to "three",
|
||||
4 to "four",
|
||||
5 to "five",
|
||||
6 to "six",
|
||||
7 to "seven",
|
||||
8 to "eight",
|
||||
9 to "nine",
|
||||
10 to "ten",
|
||||
11 to "eleven",
|
||||
12 to "twelve",
|
||||
13 to "thirteen",
|
||||
14 to "fourteen",
|
||||
15 to "fifteen",
|
||||
16 to "sixteen",
|
||||
17 to "seventeen",
|
||||
18 to "eighteen",
|
||||
19 to "nineteen",
|
||||
20 to "twenty",
|
||||
30 to "thirty",
|
||||
40 to "forty",
|
||||
50 to "fifty",
|
||||
60 to "sixty",
|
||||
70 to "seventy",
|
||||
80 to "eighty",
|
||||
90 to "ninety"
|
||||
)
|
||||
val bigNames = mapOf(
|
||||
1_000L to "thousand",
|
||||
1_000_000L to "million",
|
||||
1_000_000_000L to "billion",
|
||||
1_000_000_000_000L to "trillion",
|
||||
1_000_000_000_000_000L to "quadrillion",
|
||||
1_000_000_000_000_000_000L to "quintillion"
|
||||
)
|
||||
|
||||
fun numToText(n: Long): String {
|
||||
if (n == 0L) return "zero"
|
||||
val neg = n < 0L
|
||||
val maxNeg = n == Long.MIN_VALUE
|
||||
var nn = if (maxNeg) -(n + 1) else if (neg) -n else n
|
||||
val digits3 = IntArray(7)
|
||||
for (i in 0..6) { // split number into groups of 3 digits from the right
|
||||
digits3[i] = (nn % 1000).toInt()
|
||||
nn /= 1000
|
||||
}
|
||||
|
||||
fun threeDigitsToText(number: Int) : String {
|
||||
val sb = StringBuilder()
|
||||
if (number == 0) return ""
|
||||
val hundreds = number / 100
|
||||
val remainder = number % 100
|
||||
if (hundreds > 0) {
|
||||
sb.append(names[hundreds], " hundred")
|
||||
if (remainder > 0) sb.append(" ")
|
||||
}
|
||||
if (remainder > 0) {
|
||||
val tens = remainder / 10
|
||||
val units = remainder % 10
|
||||
if (tens > 1) {
|
||||
sb.append(names[tens * 10])
|
||||
if (units > 0) sb.append("-", names[units])
|
||||
}
|
||||
else sb.append(names[remainder])
|
||||
}
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
val strings = Array<String>(7) { threeDigitsToText(digits3[it]) }
|
||||
var text = strings[0]
|
||||
var big = 1000L
|
||||
for (i in 1..6) {
|
||||
if (digits3[i] > 0) {
|
||||
var text2 = strings[i] + " " + bigNames[big]
|
||||
if (text.length > 0) text2 += " "
|
||||
text = text2 + text
|
||||
}
|
||||
big *= 1000
|
||||
}
|
||||
if (maxNeg) text = text.dropLast(5) + "eight"
|
||||
if (neg) text = "negative " + text
|
||||
return text
|
||||
}
|
||||
|
||||
fun fourIsMagic(n: Long): String {
|
||||
if (n == 4L) return "Four is magic."
|
||||
var text = numToText(n).capitalize()
|
||||
val sb = StringBuilder()
|
||||
while (true) {
|
||||
val len = text.length.toLong()
|
||||
if (len == 4L) return sb.append("$text is four, four is magic.").toString()
|
||||
val text2 = numToText(len)
|
||||
sb.append("$text is $text2, ")
|
||||
text = text2
|
||||
}
|
||||
}
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
val la = longArrayOf(0, 4, 6, 11, 13, 75, 100, 337, -164, 9_223_372_036_854_775_807L)
|
||||
for (i in la) {
|
||||
println(fourIsMagic(i))
|
||||
println()
|
||||
}
|
||||
}
|
||||
44
Task/Four-is-magic/Lua/four-is-magic.lua
Normal file
44
Task/Four-is-magic/Lua/four-is-magic.lua
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
-- Four is magic, in Lua, 6/16/2020 db
|
||||
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" }
|
||||
local tenslist = { [0]="", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" }
|
||||
local lionlist = { [0]="", "thousand", "million", "billion", "trillion", "quadrillion", "quintillion", "sextillion", "septillion", "octillion", "nonillion", "decillion" }
|
||||
local abs, floor = math.abs, math.floor
|
||||
|
||||
local function numname(num)
|
||||
if (num == 0) then return "zero" end
|
||||
local absnum, lion, result = abs(num), 0, ""
|
||||
local function dashed(s) return s=="" and s or "-"..s end
|
||||
local function spaced(s) return s=="" and s or " "..s end
|
||||
while (absnum > 0) do
|
||||
local word, ones, tens, huns = "", absnum%10, floor(absnum/10)%10, floor(absnum/100)%10
|
||||
if (tens==0) then word = oneslist[ones]
|
||||
elseif (tens==1) then word = teenlist[ones]
|
||||
else word = tenslist[tens] .. dashed(oneslist[ones]) end
|
||||
if (huns > 0) then word = oneslist[huns] .. " hundred" .. spaced(word) end
|
||||
if (word ~= "") then result = word .. spaced(lionlist[lion]) .. spaced(result) end
|
||||
absnum = floor(absnum / 1000)
|
||||
lion = lion + 1
|
||||
end
|
||||
if (num < 0) then result = "negative " .. result end
|
||||
return result
|
||||
end
|
||||
|
||||
local function fourismagic(num)
|
||||
local function fim(num)
|
||||
local name = numname(num)
|
||||
if (num == 4) then
|
||||
return name .. " is magic."
|
||||
else
|
||||
local what = numname(#name)
|
||||
return name .. " is " .. what .. ", " .. fim(#name)
|
||||
end
|
||||
end
|
||||
local result = fim(num):gsub("^%l", string.upper)
|
||||
return result
|
||||
end
|
||||
|
||||
local numbers = { -21,-1, 0,1,2,3,4,5,6,7,8,9, 12,34,123,456,1024,1234,12345,123456,1010101 }
|
||||
for _, num in ipairs(numbers) do
|
||||
print(num, fourismagic(num))
|
||||
end
|
||||
3
Task/Four-is-magic/Mathematica/four-is-magic.math
Normal file
3
Task/Four-is-magic/Mathematica/four-is-magic.math
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
magic[num_] := Capitalize[ StringRiffle[ Partition[
|
||||
FixedPointList[IntegerName[StringLength[#], "Cardinal"] &, IntegerName[num, "Cardinal"]],
|
||||
2, 1] /. {n_, n_} :> {n, "magic"}, ", ", " is "] <> "."]
|
||||
67
Task/Four-is-magic/Nim/four-is-magic.nim
Normal file
67
Task/Four-is-magic/Nim/four-is-magic.nim
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
import strutils
|
||||
|
||||
const
|
||||
|
||||
Small = ["zero", "one", "two", "three", "four",
|
||||
"five", "six", "seven", "eight", "nine",
|
||||
"ten", "eleven", "twelve", "thirteen", "fourteen",
|
||||
"fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
|
||||
|
||||
Tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
|
||||
|
||||
Illions = ["", " thousand", " million", " billion", " trillion", " quadrillion", " quintillion"]
|
||||
|
||||
#---------------------------------------------------------------------------------------------------
|
||||
|
||||
func say(n: int64): string =
|
||||
|
||||
var n = n
|
||||
|
||||
if n < 0:
|
||||
result = "negative "
|
||||
n = -n
|
||||
|
||||
if n < 20:
|
||||
result &= Small[n]
|
||||
|
||||
elif n < 100:
|
||||
result &= Tens[n div 10]
|
||||
let m = n mod 10
|
||||
if m != 0: result &= '-' & Small[m]
|
||||
|
||||
elif n < 1000:
|
||||
result &= Small[n div 100] & " hundred"
|
||||
let m = n mod 100
|
||||
if m != 0: result &= ' ' & m.say()
|
||||
|
||||
else:
|
||||
# Work from right to left.
|
||||
var sx = ""
|
||||
var i = 0
|
||||
while n > 0:
|
||||
let m = n mod 1000
|
||||
n = n div 1000
|
||||
if m != 0:
|
||||
var ix = m.say() & Illions[i]
|
||||
if sx.len > 0: ix &= " " & sx
|
||||
sx = ix
|
||||
inc i
|
||||
result &= sx
|
||||
|
||||
#---------------------------------------------------------------------------------------------------
|
||||
|
||||
func fourIsMagic(n: int64): string =
|
||||
var n = n
|
||||
var s = n.say().capitalizeAscii()
|
||||
result = s
|
||||
while n != 4:
|
||||
n = s.len.int64
|
||||
s = n.say()
|
||||
result &= " is " & s & ", " & s
|
||||
result &= " is magic."
|
||||
|
||||
|
||||
#———————————————————————————————————————————————————————————————————————————————————————————————————
|
||||
|
||||
for n in [int64 0, 4, 6, 11, 13, 75, 100, 337, -164, int64.high]:
|
||||
echo fourIsMagic(n)
|
||||
25
Task/Four-is-magic/Perl/four-is-magic.pl
Normal file
25
Task/Four-is-magic/Perl/four-is-magic.pl
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
use Lingua::EN::Numbers qw(num2en);
|
||||
|
||||
sub cardinal {
|
||||
my($n) = @_;
|
||||
(my $en = num2en($n)) =~ s/\ and|,//g;
|
||||
$en;
|
||||
}
|
||||
|
||||
sub magic {
|
||||
my($int) = @_;
|
||||
my $str;
|
||||
while () {
|
||||
$str .= cardinal($int) . " is ";
|
||||
if ($int == 4) {
|
||||
$str .= "magic.\n";
|
||||
last
|
||||
} else {
|
||||
$int = length cardinal($int);
|
||||
$str .= cardinal($int) . ", ";
|
||||
}
|
||||
}
|
||||
ucfirst $str;
|
||||
}
|
||||
|
||||
print magic($_) for 0, 4, 6, 11, 13, 75, 337, -164, 9_876_543_209;
|
||||
80
Task/Four-is-magic/Phix/four-is-magic.phix
Normal file
80
Task/Four-is-magic/Phix/four-is-magic.phix
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
(phixonline)-->
|
||||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
|
||||
<span style="color: #000080;font-style:italic;">--<adapted from demo\rosetta\number_names.exw, which alas outputs ",", "and", uses "minus" instead of "negative", etc...></span>
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">twenties</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"zero"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"one"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"two"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"three"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"four"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"five"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"six"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"seven"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"eight"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"nine"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"ten"</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #008000;">"eleven"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"twelve"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"thirteen"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"fourteen"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"fifteen"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"sixteen"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"seventeen"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"eighteen"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"nineteen"</span><span style="color: #0000FF;">},</span>
|
||||
<span style="color: #000000;">decades</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"twenty"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"thirty"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"forty"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"fifty"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"sixty"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"seventy"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"eighty"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"ninety"</span><span style="color: #0000FF;">}</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">hundred</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><</span><span style="color: #000000;">20</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">twenties</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
|
||||
<span style="color: #008080;">elsif</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">decades</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">),</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">decades</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">),</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">&</span> <span style="color: #008000;">'-'</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">twenties</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">thousand</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><</span><span style="color: #000000;">100</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">hundred</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">elsif</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">twenties</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">100</span><span style="color: #0000FF;">),</span><span style="color: #000000;">20</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]&</span><span style="color: #008000;">" hundred"</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">twenties</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">100</span><span style="color: #0000FF;">),</span><span style="color: #000000;">20</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">&</span> <span style="color: #008000;">" hundred "</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">hundred</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">100</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">orders</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">12</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"trillion"</span><span style="color: #0000FF;">},</span>
|
||||
<span style="color: #0000FF;">{</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"billion"</span><span style="color: #0000FF;">},</span>
|
||||
<span style="color: #0000FF;">{</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"million"</span><span style="color: #0000FF;">},</span>
|
||||
<span style="color: #0000FF;">{</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"thousand"</span><span style="color: #0000FF;">}}</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">triplet</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">orders</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #0000FF;">{</span><span style="color: #004080;">atom</span> <span style="color: #000000;">order</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">name</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">orders</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
|
||||
<span style="color: #004080;">atom</span> <span style="color: #000000;">high</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">order</span><span style="color: #0000FF;">),</span>
|
||||
<span style="color: #000000;">low</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">order</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">high</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">thousand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">high</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">&</span><span style="color: #000000;">name</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">low</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">low</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #000000;">high</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">" "</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">or</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">=</span><span style="color: #008000;">""</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">thousand</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">spell</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"negative "</span>
|
||||
<span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">n</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">triplet</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
<span style="color: #000080;font-style:italic;">--</adapted from number_names.exw></span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">fourIsMagic</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">spell</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
|
||||
<span style="color: #004080;">string</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span>
|
||||
<span style="color: #008080;">while</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">4</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">spell</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">t</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">" is "</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">&</span> <span style="color: #008000;">", "</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">s</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
|
||||
<span style="color: #000000;">t</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">" is magic.\n"</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">t</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{-</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">23</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1e9</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">20140</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">100</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">130</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">151</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">999999</span><span style="color: #0000FF;">}</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</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>
|
||||
<!--
|
||||
164
Task/Four-is-magic/Python/four-is-magic.py
Normal file
164
Task/Four-is-magic/Python/four-is-magic.py
Normal file
|
|
@ -0,0 +1,164 @@
|
|||
import random
|
||||
from collections import OrderedDict
|
||||
|
||||
numbers = { # taken from https://en.wikipedia.org/wiki/Names_of_large_numbers#cite_ref-a_14-3
|
||||
1: 'one',
|
||||
2: 'two',
|
||||
3: 'three',
|
||||
4: 'four',
|
||||
5: 'five',
|
||||
6: 'six',
|
||||
7: 'seven',
|
||||
8: 'eight',
|
||||
9: 'nine',
|
||||
10: 'ten',
|
||||
11: 'eleven',
|
||||
12: 'twelve',
|
||||
13: 'thirteen',
|
||||
14: 'fourteen',
|
||||
15: 'fifteen',
|
||||
16: 'sixteen',
|
||||
17: 'seventeen',
|
||||
18: 'eighteen',
|
||||
19: 'nineteen',
|
||||
20: 'twenty',
|
||||
30: 'thirty',
|
||||
40: 'forty',
|
||||
50: 'fifty',
|
||||
60: 'sixty',
|
||||
70: 'seventy',
|
||||
80: 'eighty',
|
||||
90: 'ninety',
|
||||
100: 'hundred',
|
||||
1000: 'thousand',
|
||||
10 ** 6: 'million',
|
||||
10 ** 9: 'billion',
|
||||
10 ** 12: 'trillion',
|
||||
10 ** 15: 'quadrillion',
|
||||
10 ** 18: 'quintillion',
|
||||
10 ** 21: 'sextillion',
|
||||
10 ** 24: 'septillion',
|
||||
10 ** 27: 'octillion',
|
||||
10 ** 30: 'nonillion',
|
||||
10 ** 33: 'decillion',
|
||||
10 ** 36: 'undecillion',
|
||||
10 ** 39: 'duodecillion',
|
||||
10 ** 42: 'tredecillion',
|
||||
10 ** 45: 'quattuordecillion',
|
||||
10 ** 48: 'quinquadecillion',
|
||||
10 ** 51: 'sedecillion',
|
||||
10 ** 54: 'septendecillion',
|
||||
10 ** 57: 'octodecillion',
|
||||
10 ** 60: 'novendecillion',
|
||||
10 ** 63: 'vigintillion',
|
||||
10 ** 66: 'unvigintillion',
|
||||
10 ** 69: 'duovigintillion',
|
||||
10 ** 72: 'tresvigintillion',
|
||||
10 ** 75: 'quattuorvigintillion',
|
||||
10 ** 78: 'quinquavigintillion',
|
||||
10 ** 81: 'sesvigintillion',
|
||||
10 ** 84: 'septemvigintillion',
|
||||
10 ** 87: 'octovigintillion',
|
||||
10 ** 90: 'novemvigintillion',
|
||||
10 ** 93: 'trigintillion',
|
||||
10 ** 96: 'untrigintillion',
|
||||
10 ** 99: 'duotrigintillion',
|
||||
10 ** 102: 'trestrigintillion',
|
||||
10 ** 105: 'quattuortrigintillion',
|
||||
10 ** 108: 'quinquatrigintillion',
|
||||
10 ** 111: 'sestrigintillion',
|
||||
10 ** 114: 'septentrigintillion',
|
||||
10 ** 117: 'octotrigintillion',
|
||||
10 ** 120: 'noventrigintillion',
|
||||
10 ** 123: 'quadragintillion',
|
||||
10 ** 153: 'quinquagintillion',
|
||||
10 ** 183: 'sexagintillion',
|
||||
10 ** 213: 'septuagintillion',
|
||||
10 ** 243: 'octogintillion',
|
||||
10 ** 273: 'nonagintillion',
|
||||
10 ** 303: 'centillion',
|
||||
10 ** 306: 'uncentillion',
|
||||
10 ** 309: 'duocentillion',
|
||||
10 ** 312: 'trescentillion',
|
||||
10 ** 333: 'decicentillion',
|
||||
10 ** 336: 'undecicentillion',
|
||||
10 ** 363: 'viginticentillion',
|
||||
10 ** 366: 'unviginticentillion',
|
||||
10 ** 393: 'trigintacentillion',
|
||||
10 ** 423: 'quadragintacentillion',
|
||||
10 ** 453: 'quinquagintacentillion',
|
||||
10 ** 483: 'sexagintacentillion',
|
||||
10 ** 513: 'septuagintacentillion',
|
||||
10 ** 543: 'octogintacentillion',
|
||||
10 ** 573: 'nonagintacentillion',
|
||||
10 ** 603: 'ducentillion',
|
||||
10 ** 903: 'trecentillion',
|
||||
10 ** 1203: 'quadringentillion',
|
||||
10 ** 1503: 'quingentillion',
|
||||
10 ** 1803: 'sescentillion',
|
||||
10 ** 2103: 'septingentillion',
|
||||
10 ** 2403: 'octingentillion',
|
||||
10 ** 2703: 'nongentillion',
|
||||
10 ** 3003: 'millinillion'
|
||||
}
|
||||
numbers = OrderedDict(sorted(numbers.items(), key=lambda t: t[0], reverse=True))
|
||||
|
||||
|
||||
def string_representation(i: int) -> str:
|
||||
"""
|
||||
Return the english string representation of an integer
|
||||
"""
|
||||
if i == 0:
|
||||
return 'zero'
|
||||
|
||||
words = ['negative'] if i < 0 else []
|
||||
working_copy = abs(i)
|
||||
|
||||
for key, value in numbers.items():
|
||||
if key <= working_copy:
|
||||
times = int(working_copy / key)
|
||||
|
||||
if key >= 100:
|
||||
words.append(string_representation(times))
|
||||
|
||||
words.append(value)
|
||||
working_copy -= times * key
|
||||
|
||||
if working_copy == 0:
|
||||
break
|
||||
|
||||
return ' '.join(words)
|
||||
|
||||
|
||||
def next_phrase(i: int):
|
||||
"""
|
||||
Generate all the phrases
|
||||
"""
|
||||
while not i == 4: # Generate phrases until four is reached
|
||||
str_i = string_representation(i)
|
||||
len_i = len(str_i)
|
||||
|
||||
yield str_i, 'is', string_representation(len_i)
|
||||
|
||||
i = len_i
|
||||
|
||||
# the last phrase
|
||||
yield string_representation(i), 'is', 'magic'
|
||||
|
||||
|
||||
def magic(i: int) -> str:
|
||||
phrases = []
|
||||
|
||||
for phrase in next_phrase(i):
|
||||
phrases.append(' '.join(phrase))
|
||||
|
||||
return f'{", ".join(phrases)}.'.capitalize()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
for j in (random.randint(0, 10 ** 3) for i in range(5)):
|
||||
print(j, ':\n', magic(j), '\n')
|
||||
|
||||
for j in (random.randint(-10 ** 24, 10 ** 24) for i in range(2)):
|
||||
print(j, ':\n', magic(j), '\n')
|
||||
16
Task/Four-is-magic/Q/four-is-magic-1.q
Normal file
16
Task/Four-is-magic/Q/four-is-magic-1.q
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
C:``one`two`three`four`five`six`seven`eight`nine`ten,
|
||||
`eleven`twelve`thirteen`fourteen`fifteen`sixteen`seventeen`eighteen`nineteen / cardinal numbers <20
|
||||
|
||||
T:``ten`twenty`thirty`forty`fifty`sixty`seventy`eighty`ninety / tens
|
||||
M:``thousand`million`billion`trillion`quadrillion`quintillion`sextillion`septillion / magnitudes
|
||||
|
||||
st:{ / stringify <1000
|
||||
$[x<20; C x;
|
||||
x<100; (T;C)@'10 vs x;
|
||||
{C[y],`hundred,$[z=0;`;x z]}[.z.s] . 100 vs x] }
|
||||
|
||||
s:{$[x=0; "zero"; {" "sv string except[;`]raze x{$[x~`;x;x,y]}'M reverse til count x} st each 1000 vs x]} / stringify
|
||||
|
||||
fim:{@[;0;upper],[;"four is magic.\n"] raze 1_{y," is ",x,", "}prior s each(count s@)\[x]} / four is magic
|
||||
|
||||
1 raze fim each 0 4 8 16 25 89 365 2586 25865 369854 40000000001; / tests
|
||||
6
Task/Four-is-magic/Q/four-is-magic-2.q
Normal file
6
Task/Four-is-magic/Q/four-is-magic-2.q
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
q)show sl:count each string C / string lengths
|
||||
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]
|
||||
19 8 5 4
|
||||
62
Task/Four-is-magic/R/four-is-magic.r
Normal file
62
Task/Four-is-magic/R/four-is-magic.r
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
# provided by neonira
|
||||
|
||||
integerToText <- function(value_n_1) {
|
||||
english_words_for_numbers <- list(
|
||||
simples = c(
|
||||
'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine',
|
||||
'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'
|
||||
),
|
||||
tens = c('twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'),
|
||||
powers = c(
|
||||
'hundred' = 100,
|
||||
'thousand' = 1000,
|
||||
'million' = 1000000,
|
||||
'billion' = 1000000000,
|
||||
'trillion' = 1000000000000,
|
||||
'quadrillion' = 1000000000000000,
|
||||
'quintillion' = 1000000000000000000
|
||||
)
|
||||
)
|
||||
|
||||
buildResult <- function(x_s) {
|
||||
if (value_n_1 < 0) return(paste('minus', x_s))
|
||||
x_s
|
||||
}
|
||||
withDash <- function(a_s, b_s) paste(a_s, b_s, sep = '-')
|
||||
val <- abs(value_n_1)
|
||||
if (val < 20L) return(buildResult(english_words_for_numbers$simples[val + 1L]))
|
||||
if (val < 100L) {
|
||||
tens <- val %/% 10L - 1L
|
||||
reminder <- val %% 10L
|
||||
if (reminder == 0L) return(buildResult(english_words_for_numbers$ten[tens]))
|
||||
return(buildResult(withDash(english_words_for_numbers$ten[tens], Recall(reminder))))
|
||||
}
|
||||
|
||||
index <- l <- length(english_words_for_numbers$powers)
|
||||
for(power in seq_len(l)) {
|
||||
if (val < english_words_for_numbers$powers[power]) {
|
||||
index <- power - 1L
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
f <- Recall(val %/% english_words_for_numbers$powers[index])
|
||||
reminder <- val %% english_words_for_numbers$powers[index]
|
||||
if (reminder == 0L) return(buildResult(paste(f, names(english_words_for_numbers$powers)[index])))
|
||||
buildResult(paste(f, names(english_words_for_numbers$powers)[index], Recall(reminder)))
|
||||
}
|
||||
|
||||
magic <- function(value_n_1) {
|
||||
text <- vector('character')
|
||||
while(TRUE) {
|
||||
r <- integerToText(value_n_1)
|
||||
nc <- nchar(r)
|
||||
complement <- ifelse(value_n_1 == 4L, "is magic", paste("is", integerToText(nc)))
|
||||
text[length(text) + 1L] <- paste(r, complement)
|
||||
if (value_n_1 == 4L) break
|
||||
value_n_1 <- nc
|
||||
}
|
||||
|
||||
buildSentence <- function(x_s) paste0(toupper(substr(x_s, 1L, 1L)), substring(x_s, 2L), '.')
|
||||
buildSentence(paste(text, collapse = ', '))
|
||||
}
|
||||
22
Task/Four-is-magic/REXX/four-is-magic.rexx
Normal file
22
Task/Four-is-magic/REXX/four-is-magic.rexx
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
/*REXX pgm converts a # to English into the phrase: a is b, b is c, ... four is magic. */
|
||||
numeric digits 3003 /*be able to handle gihugic numbers. */
|
||||
parse arg x /*obtain optional numbers from the C.L.*/
|
||||
if x='' then x= -164 0 4 6 11 13 75 100 337 9223372036854775807 /*use these defaults?*/
|
||||
@.= . /*stemmed array used for memoization. */
|
||||
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. */
|
||||
say /*display a blank line between outputs.*/
|
||||
end /*j*/
|
||||
exit /*stick a fork in it, we're all done. */
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
4_is: procedure expose @.; parse arg #,,$ /*obtain the start number.*/
|
||||
if #\==4 then do until L==4 /*Not 4? Process number.*/
|
||||
@.#= $spell#(# 'quiet minus negative') /*spell number in English.*/
|
||||
#= @.#; L= length(#) /*get the length of spelt#*/
|
||||
if @.L==. then @.L= $spell#(L 'quiet') /*¬spelt before? Spell it.*/
|
||||
$= $ # "is" @.L',' /*add phrase to the answer*/
|
||||
#= L /*use the new number, ··· */
|
||||
end /*until*/ /* ··· which will be spelt*/
|
||||
$= strip($ 'four is magic.') /*finish the sentence with the finale. */
|
||||
parse var $ first 2 other; upper first /*capitalize the first letter of output*/
|
||||
return first || other /*return the sentence to the invoker. */
|
||||
55
Task/Four-is-magic/Racket/four-is-magic.rkt
Normal file
55
Task/Four-is-magic/Racket/four-is-magic.rkt
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
#lang racket
|
||||
|
||||
(require rackunit)
|
||||
|
||||
(define smalls
|
||||
(map symbol->string
|
||||
'(zero one two three four five six seven eight nine ten eleven twelve
|
||||
thirteen fourteen fifteen sixteen seventeen eighteen nineteen)))
|
||||
|
||||
(define tens
|
||||
(map symbol->string
|
||||
'(zero ten twenty thirty forty fifty sixty seventy eighty ninety)))
|
||||
|
||||
(define larges
|
||||
(map symbol->string
|
||||
'(thousand million billion trillion quadrillion quintillion sextillion
|
||||
septillion octillion nonillion decillion undecillion duodecillion
|
||||
tredecillion quattuordecillion quindecillion sexdecillion
|
||||
septendecillion octodecillion novemdecillion vigintillion)))
|
||||
|
||||
(define (number->words n)
|
||||
(define (step div suffix separator [subformat number->words])
|
||||
(define-values [q r] (quotient/remainder n div))
|
||||
(define S (if suffix (~a (subformat q) " " suffix) (subformat q)))
|
||||
(if (zero? r) S (~a S separator (number->words r))))
|
||||
(cond [(< n 0) (~a "negative " (number->words (- n)))]
|
||||
[(< n 20) (list-ref smalls n)]
|
||||
[(< n 100) (step 10 #f "-" (curry list-ref tens))]
|
||||
[(< n 1000) (step 100 "hundred" " ")]
|
||||
[else (let loop ([N 1000000] [D 1000] [unit larges])
|
||||
(cond [(null? unit)
|
||||
(error 'number->words "number too big: ~e" n)]
|
||||
[(< n N) (step D (car unit) " ")]
|
||||
[else (loop (* 1000 N) (* 1000 D) (cdr unit))]))]))
|
||||
|
||||
(define (first-cap s)
|
||||
(~a (string-upcase (substring s 0 1)) (substring s 1)))
|
||||
|
||||
(define (magic word [acc null])
|
||||
(if (equal? word "four")
|
||||
(string-join (reverse (cons "four is magic." acc)) ", \n")
|
||||
(let* ([word-len (string-length word)]
|
||||
[words (number->words word-len)])
|
||||
(magic words
|
||||
(cons (string-append word " is " words) acc)))))
|
||||
|
||||
(define (number-magic n)
|
||||
(first-cap (magic (number->words n))))
|
||||
|
||||
(for ([n (append (range 11)
|
||||
'(-10 23 172 20140 100 130 999999 876000000
|
||||
874143425855745733896030))])
|
||||
(displayln n)
|
||||
(displayln (number-magic n))
|
||||
(newline))
|
||||
19
Task/Four-is-magic/Raku/four-is-magic.raku
Normal file
19
Task/Four-is-magic/Raku/four-is-magic.raku
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
use Lingua::EN::Numbers; # Version 2.4.0 or higher
|
||||
|
||||
sub card ($n) { cardinal($n).subst(/','/, '', :g) }
|
||||
|
||||
sub magic (Int $int is copy) {
|
||||
my $string;
|
||||
loop {
|
||||
$string ~= "{ card($int) } is ";
|
||||
if $int = ($int == 4) ?? 0 !! card($int).chars {
|
||||
$string ~= "{ card($int) }, "
|
||||
} else {
|
||||
$string ~= "magic.\n";
|
||||
last
|
||||
}
|
||||
}
|
||||
$string.tc
|
||||
}
|
||||
|
||||
.&magic.say for 0, 4, 6, 11, 13, 75, 337, -164, 9876543209, 2**256;
|
||||
110
Task/Four-is-magic/Ring/four-is-magic.ring
Normal file
110
Task/Four-is-magic/Ring/four-is-magic.ring
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
/* Checking numbers from 0 to 10 */
|
||||
for c = 0 to 10
|
||||
See checkmagic(c) + NL
|
||||
next
|
||||
|
||||
|
||||
/* The functions */
|
||||
|
||||
Func CheckMagic numb
|
||||
CardinalN = ""
|
||||
Result = ""
|
||||
if isnumber(numb) = false or numb < 0 or numb > 999_999_999_999_999
|
||||
Return "ERROR: Number entered is incorrect"
|
||||
ok
|
||||
if numb = 4
|
||||
Result = "Four is magic."
|
||||
else
|
||||
While True
|
||||
if CardinalN = "four"
|
||||
Result += "four is magic"
|
||||
exit
|
||||
ok
|
||||
strnumb = StringNumber(numb)
|
||||
CardinalN = StringNumber(len(strnumb))
|
||||
Result += strnumb + " is " + CardinalN + ", "
|
||||
numb = len(strnumb)
|
||||
End
|
||||
Result += "."
|
||||
Result = upper(Result[1]) + Right(Result, len(Result) -1)
|
||||
ok
|
||||
|
||||
Return Result
|
||||
|
||||
Func StringNumber cnumb
|
||||
|
||||
NumStr = [:n0 = "zero", :n1 = "one", :n2 = "two", :n3 = "three", :n4 = "four", :n5 = "five",
|
||||
:n6 = "six", :n7 = "seven", :n8 = "eight", :n9 = "nine", :n10 = "ten",
|
||||
:n11 = "eleven", :n12 = "twelve", :n13 = "thirteen", :n14 = "fourteen", :n15 = "fifteen",
|
||||
:n16 = "sixteen", :n17 = "seventeen", :n18 = "eighteen", :n19 = "nineteen",
|
||||
:n20 = "twenty", :n30 = "thirty", :n40 = "fourty", :n50 = "fifty", :n60 = "sixty", :n70 = "seventy", :n80 = "eighty", :n90 = "ninety"]
|
||||
|
||||
numLev = [:l1 = "", :l2 = "thousand", :l3 = "million", :l4 = "billion", :l5 = "trillion"]
|
||||
|
||||
Result = ""
|
||||
|
||||
if cnumb > 0
|
||||
decimals(0)
|
||||
snumb = string((cnumb))
|
||||
lnumb = [""]
|
||||
fl = floor(len(snumb) / 3)
|
||||
if fl > 0
|
||||
for i = 1 to fl
|
||||
lnumb[i] = right(snumb, 3)
|
||||
snumb = left(snumb, len(snumb) -3)
|
||||
lnumb + ""
|
||||
next
|
||||
if (len(snumb) % 3) > 0
|
||||
lnumb[len(lnumb)] = snumb
|
||||
else
|
||||
del(lnumb, len(lnumb))
|
||||
ok
|
||||
else
|
||||
lnumb[1] = snumb
|
||||
ok
|
||||
for l = len(lnumb) to 1 step -1
|
||||
bnumb = lnumb[l]
|
||||
bResult = ""
|
||||
if number(bnumb) != 0
|
||||
for n = len(bnumb) to 1 step -1
|
||||
if (len(bnumb) = 3 and n = 2) or (len(bnumb) = 2 and n = 1)
|
||||
if number(bnumb[n]) > 1
|
||||
eval("bResult = NumStr[:n" + bnumb[n] + "0] + ' ' + bResult")
|
||||
elseif number(bnumb[n]) = 1
|
||||
eval("bResult = NumStr[:n" + bnumb[n] + bnumb[n+1] + "] + ' ' + bResult")
|
||||
ok
|
||||
else
|
||||
if len(bnumb) = 3 and n = 1 and number(bnumb[1]) > 0
|
||||
if trim(bResult) != ""
|
||||
bResult = " " + bResult
|
||||
ok
|
||||
if number(bnumb[1]) > 1
|
||||
bResult = "hundreds" + bResult
|
||||
else
|
||||
bResult = "hundred" + bResult
|
||||
ok
|
||||
if left(trim(bResult), 7) = "hundred"
|
||||
bResult = bResult + " "
|
||||
ok
|
||||
ok
|
||||
if (len(bnumb) = 3 and n = 1 and number(bnumb[1]) = 0) OR (len(bnumb) = n and number(bnumb[n]) = 0) OR (len(bnumb) = 3 and number(bnumb[2]) = 1) OR (len(bnumb) = 2 and number(bnumb[1]) = 1)
|
||||
loop
|
||||
ok
|
||||
eval("bResult = NumStr[:n" + bnumb[n] + "] + ' ' + bResult")
|
||||
ok
|
||||
next
|
||||
Result = Result + bResult
|
||||
if l > 1
|
||||
if number(bnumb) > 1
|
||||
eval("Result = Result + numLev[:l" + l + "] + 's ' ")
|
||||
else
|
||||
eval("Result = Result + numLev[:l" + l + "] + ' ' ")
|
||||
ok
|
||||
ok
|
||||
ok
|
||||
next
|
||||
else
|
||||
Result = Result + NumStr[:n0]
|
||||
ok
|
||||
|
||||
Return trim(Result)
|
||||
76
Task/Four-is-magic/Ruby/four-is-magic.rb
Normal file
76
Task/Four-is-magic/Ruby/four-is-magic.rb
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
module NumberToWord
|
||||
|
||||
NUMBERS = { # taken from https://en.wikipedia.org/wiki/Names_of_large_numbers#cite_ref-a_14-3
|
||||
1 => 'one',
|
||||
2 => 'two',
|
||||
3 => 'three',
|
||||
4 => 'four',
|
||||
5 => 'five',
|
||||
6 => 'six',
|
||||
7 => 'seven',
|
||||
8 => 'eight',
|
||||
9 => 'nine',
|
||||
10 => 'ten',
|
||||
11 => 'eleven',
|
||||
12 => 'twelve',
|
||||
13 => 'thirteen',
|
||||
14 => 'fourteen',
|
||||
15 => 'fifteen',
|
||||
16 => 'sixteen',
|
||||
17 => 'seventeen',
|
||||
18 => 'eighteen',
|
||||
19 => 'nineteen',
|
||||
20 => 'twenty',
|
||||
30 => 'thirty',
|
||||
40 => 'forty',
|
||||
50 => 'fifty',
|
||||
60 => 'sixty',
|
||||
70 => 'seventy',
|
||||
80 => 'eighty',
|
||||
90 => 'ninety',
|
||||
100 => 'hundred',
|
||||
1000 => 'thousand',
|
||||
10 ** 6 => 'million',
|
||||
10 ** 9 => 'billion',
|
||||
10 ** 12 => 'trillion',
|
||||
10 ** 15 => 'quadrillion',
|
||||
10 ** 18 => 'quintillion',
|
||||
10 ** 21 => 'sextillion',
|
||||
10 ** 24 => 'septillion',
|
||||
10 ** 27 => 'octillion',
|
||||
10 ** 30 => 'nonillion',
|
||||
10 ** 33 => 'decillion'}.reverse_each.to_h
|
||||
|
||||
refine Integer do
|
||||
def to_english
|
||||
return 'zero' if i.zero?
|
||||
words = self < 0 ? ['negative'] : []
|
||||
i = self.abs
|
||||
NUMBERS.each do |k, v|
|
||||
if k <= i then
|
||||
times = i/k
|
||||
words << times.to_english if k >= 100
|
||||
words << v
|
||||
i -= times * k
|
||||
end
|
||||
return words.join(" ") if i.zero?
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
using NumberToWord
|
||||
|
||||
def magic4(n)
|
||||
words = []
|
||||
until n == 4
|
||||
s = n.to_english
|
||||
n = s.size
|
||||
words << "#{s} is #{n.to_english}"
|
||||
end
|
||||
words << "four is magic."
|
||||
words.join(", ").capitalize
|
||||
end
|
||||
|
||||
[0, 4, 6, 11, 13, 75, 337, -164, 9_876_543_209].each{|n| puts magic4(n) }
|
||||
78
Task/Four-is-magic/Rust/four-is-magic.rust
Normal file
78
Task/Four-is-magic/Rust/four-is-magic.rust
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
fn main() {
|
||||
magic(4);
|
||||
magic(2_340);
|
||||
magic(765_000);
|
||||
magic(27_000_001);
|
||||
magic(999_123_090);
|
||||
magic(239_579_832_723_441);
|
||||
magic(std::u64::MAX);
|
||||
}
|
||||
|
||||
fn magic(num: u64) {
|
||||
if num == 4 {
|
||||
println!("four is magic!");
|
||||
println!();
|
||||
return;
|
||||
}
|
||||
let name = number_name(num);
|
||||
let len = name.len() as u64;
|
||||
print!("{} is {}, ", name, number_name(len));
|
||||
magic(len);
|
||||
}
|
||||
|
||||
|
||||
const LOW: &'static [&'static str] = &[
|
||||
"zero", "one", "two", "three", "four", "five",
|
||||
"six", "seven", "eight","nine", "ten",
|
||||
"eleven", "twelve", "thirteen", "fourteen", "fifteen",
|
||||
"sixteen", "seventeen", "eighteen", "nineteen"
|
||||
];
|
||||
const MED: &'static [&'static str] = &[
|
||||
"twenty", "thirty", "forty", "fifty",
|
||||
"sixy", "seventy", "eighty", "ninety"
|
||||
];
|
||||
const HIGH: &'static [&'static str] = &[
|
||||
"thousand", "million", "billion",
|
||||
"trillion", "quadrillion", "quintillion"
|
||||
];
|
||||
|
||||
fn number_name(num: u64) -> String {
|
||||
if num < 20 {
|
||||
return LOW[num as usize].to_string();
|
||||
}
|
||||
if num < 100 {
|
||||
let index = ((num / 10) - 2) as usize;
|
||||
let tens = MED[index].to_string();
|
||||
let remainder = num % 10;
|
||||
if remainder > 0 {
|
||||
return format!("{}-{}", tens, number_name(remainder));
|
||||
}
|
||||
return tens;
|
||||
}
|
||||
if num < 1000 {
|
||||
let hundreds = LOW[(num / 100) as usize];
|
||||
let remainder = num % 100;
|
||||
if remainder > 0 {
|
||||
return format!("{} hundred {}", hundreds, number_name(remainder));
|
||||
}
|
||||
return format!("{} hundred", hundreds);
|
||||
}
|
||||
|
||||
let mut remainder = num % 1000;
|
||||
let mut cur = if remainder > 0 { number_name(remainder) } else { "".to_string() };
|
||||
let mut n = num / 1000;
|
||||
|
||||
for noun in HIGH.iter() {
|
||||
if n > 0 {
|
||||
remainder = n % 1000;
|
||||
if remainder > 0 {
|
||||
// this condition resolves double space issues
|
||||
cur =
|
||||
if cur.len() > 0 { format!("{} {} {}", number_name(remainder), noun, cur ) }
|
||||
else { format!("{} {}", number_name(remainder), noun) }
|
||||
}
|
||||
n /= 1000;
|
||||
}
|
||||
}
|
||||
return cur;
|
||||
}
|
||||
23
Task/Four-is-magic/Sidef/four-is-magic.sidef
Normal file
23
Task/Four-is-magic/Sidef/four-is-magic.sidef
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
func cardinal(n) {
|
||||
static lingua_en = frequire("Lingua::EN::Numbers")
|
||||
lingua_en.num2en(n) - / and|,/g
|
||||
}
|
||||
|
||||
func four_is_magic(n) {
|
||||
var str = ""
|
||||
loop {
|
||||
str += (cardinal(n) + " is ")
|
||||
if (n == 4) {
|
||||
str += "magic."
|
||||
break
|
||||
} else {
|
||||
n = cardinal(n).len
|
||||
str += (cardinal(n) + ", ")
|
||||
}
|
||||
}
|
||||
str.tc
|
||||
}
|
||||
|
||||
[0, 4, 6, 11, 13, 75, 337, -164, 9_876_543_209].each { |n|
|
||||
say four_is_magic(n)
|
||||
}
|
||||
24
Task/Four-is-magic/Swift/four-is-magic.swift
Normal file
24
Task/Four-is-magic/Swift/four-is-magic.swift
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
import Foundation
|
||||
|
||||
func fourIsMagic(_ number: NSNumber) -> String {
|
||||
let formatter = NumberFormatter()
|
||||
formatter.numberStyle = .spellOut
|
||||
formatter.locale = Locale(identifier: "en_EN")
|
||||
|
||||
var result: [String] = []
|
||||
|
||||
var numberString = formatter.string(from: number)!
|
||||
result.append(numberString.capitalized)
|
||||
|
||||
while numberString != "four" {
|
||||
numberString = formatter.string(from: NSNumber(value: numberString.count))!
|
||||
result.append(contentsOf: [" is ", numberString, ", ", numberString])
|
||||
}
|
||||
|
||||
result.append(" is magic.")
|
||||
return result.joined()
|
||||
}
|
||||
|
||||
for testInput in [23, 1000000000, 20140, 100, 130, 151, -7] {
|
||||
print(fourIsMagic(testInput as NSNumber))
|
||||
}
|
||||
81
Task/Four-is-magic/UNIX-Shell/four-is-magic.sh
Normal file
81
Task/Four-is-magic/UNIX-Shell/four-is-magic.sh
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
#!/usr/bin/env bash
|
||||
name_of() {
|
||||
# return the English name for a numeric value
|
||||
local -i n=$1
|
||||
|
||||
if (( n < 0 )); then
|
||||
printf 'negative %s\n' "$(name_of $(( -n )))"
|
||||
return 0
|
||||
fi
|
||||
|
||||
# Names for numbers that fit in a bash integer
|
||||
local -A 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
|
||||
[12]=twelve [13]=thirteen [14]=fourteen [15]=fifteen
|
||||
[16]=sixteen [17]=seventeen [18]=eighteen [19]=nineteen
|
||||
[20]=twenty [30]=thirty [40]=forty [50]=fifty [60]=sixty
|
||||
[70]=seventy [80]=eighty [90]=ninety [100]=hundred
|
||||
[1000]=thousand [1000000]=million [1000000000]=billion
|
||||
[1000000000000]=trillion [1000000000000000]=quadrillion
|
||||
[1000000000000000000]=quintillion)
|
||||
|
||||
# The powers of 10 above 10, in descending order
|
||||
local powers_of_10=($(printf '%s\n' "${!names[@]}" | sort -nr | grep '00$'))
|
||||
|
||||
# find the largest power of 10 that is smaller than n
|
||||
local -i i=0
|
||||
local -i p=${powers_of_10[i]}
|
||||
while (( p > n && i < ${#powers_of_10[@]}-1 )); do
|
||||
i=i+1
|
||||
p=${powers_of_10[$i]}
|
||||
done
|
||||
|
||||
# if we found one, split on it and construct quotient 'name' remainder
|
||||
if (( n >= p )); then
|
||||
local -i quotient=n/p
|
||||
local -i remainder=n%p
|
||||
local remname=
|
||||
if (( remainder > 0 )); then
|
||||
remname=$(name_of $remainder)
|
||||
fi
|
||||
printf '%s %s\n' "$(name_of $quotient)" "${names[$p]}${remname:+ $remname}"
|
||||
elif (( n > 20 )); then
|
||||
# things are a little different under 100, since the multiples of
|
||||
# 10 have their own names
|
||||
local -i remainder=n%10
|
||||
local -i tens=n-remainder
|
||||
local remname=
|
||||
if (( remainder > 0 )); then
|
||||
remname=-$(name_of $remainder)
|
||||
fi
|
||||
printf '%s\n' "${names[$tens]}${remname:+$remname}"
|
||||
else
|
||||
printf '%s\n' "${names[$n]}"
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Convert numbers into the length of their names
|
||||
# Display the series of values in name form until
|
||||
# the length turns into four; then terminate with "four is magic."
|
||||
# Again, takes a second argument, this time a prefix, to
|
||||
# facilitate tail recursion.
|
||||
four_is_magic() {
|
||||
local -i n=$1
|
||||
local prefix=$2
|
||||
local name=$(name_of $n)
|
||||
|
||||
# capitalize the first entry
|
||||
if [[ -z $prefix ]]; then
|
||||
name=${name^}
|
||||
fi
|
||||
|
||||
# Stop at 4, otherwise count the length of the name and recurse
|
||||
if (( $n == 4 )); then
|
||||
printf '%s%s is magic.\n' "${prefix:+$prefix, }" "$name"
|
||||
else
|
||||
local -i len=${#name}
|
||||
four_is_magic "$len" "${prefix:+$prefix, }$name is $(name_of $len)"
|
||||
fi
|
||||
}
|
||||
76
Task/Four-is-magic/V-(Vlang)/four-is-magic.v
Normal file
76
Task/Four-is-magic/V-(Vlang)/four-is-magic.v
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
import math
|
||||
fn main() {
|
||||
for n in [i64(0), 4, 6, 11, 13, 75, 100, 337, -164,
|
||||
math.max_i64,
|
||||
] {
|
||||
println(four_is_magic(n))
|
||||
}
|
||||
}
|
||||
|
||||
fn four_is_magic(nn i64) string {
|
||||
mut n := nn
|
||||
mut s := say(n)
|
||||
s = s[..1].to_upper() + s[1..]
|
||||
mut t := s
|
||||
for n != 4 {
|
||||
n = i64(s.len)
|
||||
s = say(n)
|
||||
t += " is " + s + ", " + s
|
||||
}
|
||||
t += " is magic."
|
||||
return t
|
||||
}
|
||||
|
||||
const small = ["zero", "one", "two", "three", "four", "five", "six",
|
||||
"seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen",
|
||||
"fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
|
||||
const tens = ["", "", "twenty", "thirty", "forty",
|
||||
"fifty", "sixty", "seventy", "eighty", "ninety"]
|
||||
const illions = ["", " thousand", " million", " billion",
|
||||
" trillion", " quadrillion", " quintillion"]
|
||||
|
||||
fn say(nn i64) string {
|
||||
mut t := ''
|
||||
mut n := nn
|
||||
if n < 0 {
|
||||
t = "negative "
|
||||
// Note, for math.MinInt64 this leaves n negative.
|
||||
n = -n
|
||||
}
|
||||
match true {
|
||||
n < 20 {
|
||||
t += small[n]
|
||||
}
|
||||
n < 100 {
|
||||
t += tens[n/10]
|
||||
s := n % 10
|
||||
if s > 0 {
|
||||
t += "-" + small[s]
|
||||
}
|
||||
}
|
||||
n < 1000 {
|
||||
t += small[n/100] + " hundred"
|
||||
s := n % 100
|
||||
if s > 0 {
|
||||
t += " " + say(s)
|
||||
}
|
||||
}
|
||||
else {
|
||||
// work right-to-left
|
||||
mut sx := ""
|
||||
for i := 0; n > 0; i++ {
|
||||
p := n % 1000
|
||||
n /= 1000
|
||||
if p > 0 {
|
||||
mut ix := say(p) + illions[i]
|
||||
if sx != "" {
|
||||
ix += " " + sx
|
||||
}
|
||||
sx = ix
|
||||
}
|
||||
}
|
||||
t += sx
|
||||
}
|
||||
}
|
||||
return t
|
||||
}
|
||||
58
Task/Four-is-magic/Wren/four-is-magic.wren
Normal file
58
Task/Four-is-magic/Wren/four-is-magic.wren
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
import "./str" for Str
|
||||
|
||||
var small = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven",
|
||||
"twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
|
||||
|
||||
var tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
|
||||
|
||||
var illions = ["", " thousand", " million", " billion"," trillion", " quadrillion", " quintillion"]
|
||||
|
||||
var say
|
||||
say = Fn.new { |n|
|
||||
var t = ""
|
||||
if (n < 0) {
|
||||
t = "negative "
|
||||
n = -n
|
||||
}
|
||||
if (n < 20) {
|
||||
t = t + small[n]
|
||||
} else if (n < 100) {
|
||||
t = t + tens[(n/10).floor]
|
||||
var s = n % 10
|
||||
if (s > 0) t = t + "-" + small[s]
|
||||
} else if (n < 1000) {
|
||||
t = t + small[(n/100).floor] + " hundred"
|
||||
var s = n % 100
|
||||
if (s > 0) t = t + " " + say.call(s)
|
||||
} else {
|
||||
var sx = ""
|
||||
var i = 0
|
||||
while (n > 0) {
|
||||
var p = n % 1000
|
||||
n = (n/1000).floor
|
||||
if (p > 0) {
|
||||
var ix = say.call(p) + illions[i]
|
||||
if (sx != "") ix = ix + " " + sx
|
||||
sx = ix
|
||||
}
|
||||
i = i + 1
|
||||
}
|
||||
t = t + sx
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
var fourIsMagic = Fn.new { |n|
|
||||
var s = Str.capitalize(say.call(n))
|
||||
var t = s
|
||||
while (n != 4) {
|
||||
n = s.count
|
||||
s = say.call(n)
|
||||
t = t + " is " + s + ", " + s
|
||||
}
|
||||
return t + " is magic."
|
||||
}
|
||||
|
||||
for (n in [0, 4, 6, 11, 13, 75, 100, 337, -164, 9007199254740991]) {
|
||||
System.print(fourIsMagic.call(n))
|
||||
}
|
||||
14
Task/Four-is-magic/Zkl/four-is-magic-1.zkl
Normal file
14
Task/Four-is-magic/Zkl/four-is-magic-1.zkl
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
fcn fourIsMagic(int){
|
||||
if(int==0) return("Zero is four, four is magic.");
|
||||
string:="";
|
||||
while(1){ c:=nth(int,False);
|
||||
string+="%s is ".fmt(c);
|
||||
if(int = ( if(int==4) 0 else c.len() )){
|
||||
string+="%s, ".fmt(nth(int,False));
|
||||
}else{
|
||||
string+="magic.";
|
||||
break;
|
||||
}
|
||||
}
|
||||
string[0].toUpper() + string[1,*]
|
||||
}
|
||||
3
Task/Four-is-magic/Zkl/four-is-magic-2.zkl
Normal file
3
Task/Four-is-magic/Zkl/four-is-magic-2.zkl
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
foreach n in (T(0,4,6,11,13,75,337,-164,9876543209)){
|
||||
println(fourIsMagic(n),"\n")
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue