Cztery to magiczna liczba

26

Nie sprawdziłem piaskownicy przed opublikowaniem tego wyzwania - wygląda na to, że wyzwanie to zaproponował Cᴏɴᴏʀ O'Bʀɪᴇɴ .

Biorąc pod uwagę liczbę całkowitą, napisz program, który wypisze zagadkę „cztery to magiczna liczba”

  • Cztery to magiczna liczba
  • Pięć to cztery, a cztery to magiczna liczba
  • Sześć to trzy, a trzy to pięć, a pięć to cztery, a cztery to magiczna liczba
  • Jedenaście to sześć, a sześć to trzy, a trzy to pięć, a pięć to cztery, a cztery to magiczna liczba
  • Pięćset to jedenaście, a jedenaście to sześć, a sześć to trzy, a trzy to pięć, a pięć to cztery, a cztery to magiczna liczba

Jeśli znasz już zagadkę lub jesteś zbyt leniwy, aby ją rozwiązać, pragniesz dowiedzieć się, czym jest zagadka, oto wyjaśnienie

Następny numer to liczba liter w poprzednim numerze. Na przykład pięć ma cztery litery, więc następna liczba to cztery .

sześć ma trzy litery, więc następna liczba to 3 , a trzy mają pięć liter, więc następna liczba to 5 , a pięć ma cztery litery, więc następna liczba to 4

Powód, dla którego zagadka kończy się na czwartej, jest taki, że cztery mają cztery litery , a cztery to cztery, a cztery to cztery, a cztery to cztery ... (cztery to magiczna liczba)

Przypadki testowe

0 =>
  Zero is four and four is the magic number
1 =>
  One is three and three is five and five is four and four is the magic number
2 =>
  Two is three and three is five and five is four and four is the magic number
3 => 
  Three is five and five is four and four is the magic number
4 =>
  Four is the magic number
5 => 
  Five is four and four is the magic number
6 =>
  Six is three and three is five and five is four and four is the magic number
7 =>
  Seven is five and five is four and four is the magic number
8 =>
  Eight is five and five is four and four is the magic number
9 =>
  Nine is four and four is the magic number
10 =>
  Ten is three and three is five and five is four and four is the magic number
17 =>
  Seventeen is nine and nine is four and four is the magic number
100 =>
  One Hundred is ten and ten is three and three is five and five is four and four is the magic number
142 =>
  One Hundred Forty Two is eighteen and eighteen is eight and eight is five and five is four and four is the magic number
1,000 =>
  One Thousand is eleven and eleven is six and six is three and three is five and five is four and four is the magic number
1,642 =>
  One Thousand Six Hundred Forty Two is twenty nine and twenty nine is ten and ten is three and three is five and five is four and four is the magic number
70,000 =>
  Seventy Thousand is fifteen and fifteen is seven and seven is five and five is four and four is the magic number
131,072 =>
  One Hundred Thirty One Thousand Seventy Two is thirty seven and thirty seven is eleven and eleven is six and six is three and three is five and five is four and four is the magic number
999,999 =>
  Nine Hundred Ninety Nine Thousand Nine Hundred Ninety Nine is fifty and fifty is five and five is four and four is the magic number

Zasady

  • Dane wejściowe mogą być pobierane z funkcji STDINlub jako argument funkcji
  • Wartość wejściowa będzie liczbą dodatnią od 0 do 999,999
  • Dane wejściowe będą zawierały tylko liczby (będą zgodne z wyrażeniem regularnym ^[0-9]+$)
  • Dane wejściowe można traktować jako liczbę całkowitą lub ciąg znaków
  • Po przekształceniu na ciąg słów spacje i łączniki nie powinny być uwzględniane w liczeniu (100 [sto] to 10 znaków, a nie 11. 1,742 [tysiąc siedemset czterdzieści dwa] to 31 znaków, a nie 36)
  • Po przekształceniu na ciąg 100 powinno być Sto, a nie Sto lub Sto, 1000 powinno być Tysiąca, a nie Tysiąca lub Tysiąca.
  • Po przeliczeniu na ciąg 142 powinny być sto czterdzieści dwa, nie Sto i czterdzieści dwa
  • Dane wyjściowe nie rozróżniają wielkości liter i powinny mieć format „ N to K, a K to M, a M to ... a cztery to liczba magiczna” (chyba że dane wejściowe to 4, w takim przypadku dane wyjściowe powinny być po prostu „cztery to magiczna liczba ”)
  • Dane wyjściowe mogą używać liczb zamiast liter („5 to 4, a 4 to magiczna liczba” zamiast „pięć to cztery, a cztery to magiczna liczba”), o ile Twój program jest zawsze spójny
  • Dane wyjściowe mogą być albo wartością zwracaną przez funkcję, albo drukowane na STDOUT
  • Standardowe luki zastosowanie
  • To jest golf golfowy , więc wygrywa najkrótszy program w bajtach. Powodzenia!

Premia

-30 bajtów, jeśli program działa, gdy wartość wejściowa wynosi od -999,999 do 999,999.

Liczby ujemne po przeliczeniu na słowa mają po prostu „ujemne” przed sobą. Na przykład -4„Negatywna czwórka”, Negatywna czwórka to dwanaście, a dwanaście to sześć, a sześć to trzy, a trzy to pięć, a pięć to cztery, a cztery to magiczna liczba.

-150 bajtów, jeśli program nie korzysta z żadnych wbudowanych funkcji do generowania ciągu reprezentującego liczbę

Tabela liderów

To jest fragment kodu, który generuje zarówno tabelę wyników, jak i przegląd zwycięzców według języka.

Aby mieć pewność, że Twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown

## Language Name, N bytes

Gdzie N jest rozmiarem twojego przesłania w bajtach

Jeśli chcesz dołączyć wiele liczb do nagłówka (na przykład przekreślając stare wyniki lub włączając flagi w liczbie bajtów), po prostu upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku

## Language Name, <s>K</s> X + 2 = N bytes

Pokaż fragment kodu

code-golf number Jojodmo
źródło
Czy istnieje maksymalny możliwy wkład?
Arcturus,
7
W przyszłości sprawdź także piaskownicę, aby sprawdzić, czy ktoś inny ma Twój pomysł .
El'endia Starman
@ El'endiaStarman W porządku, dodałem trochę tekstu na górze wyzwania prowadzącego do tego postu
Jojodmo,
Twój wbudowany bonus funkcji powinien być bardziej podobny do -150 do -200 bajtów.
TanMath
1
Po prostu to wyrzucę - nawet najbardziej szalenie zoptymalizowana liczba konwerterów nazw ledwie kosztuje mniej niż 150 bajtów w większości języków, ponieważ - -150 jest bardziej pułapką niż premią.
ricdesi

Odpowiedzi:

9

Bash + typowe narzędzia (w tym gry bsd), 123 - 30 = 93 bajty

for((n=$1;n-4;n=m)){
m=`number -l -- $n|sed 's/nus/&&/;s/\W//g'`
s+="$n is $[m=${#m}] and "
}
echo $s 4 is the magic number

Na szczęście wyjście z BSD gry numbernarzędzie jest prawie dokładnie to, czego potrzebujemy. Wszystkie liczby wyjściowe są zapisywane numerycznie, a nie słownie, jak w 8 punkcie:

$ ./4magic.sh 131072
131072 is 37 and 37 is 11 and 11 is 6 and 6 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
$ ./4magic.sh -4
-4 is 12 and 12 is 6 and 6 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
$
Cyfrowa trauma
źródło
6

C, 263 261 bajtów - 180 = 81

char*i="jmmonnmoonmpprrqqsrrjjddeeecdd",x;f(n,c){return!n?n:n<0?f(-n,8):n<100?c+i[n<20?n:n%10]-i[20+n/10]:f(n/1000,8)+f(n/100%10,7)+f(n/100%10,0)+c;}main(int c,char**v){for(c=atoi(*++v);c-4;c=x)printf("%d is %d and ",c,x=c?f(c,0)):4;puts("4 is the magic number");}

Zainspirowany odpowiedzią Cole'a Camerona . Pomyślałem, że mógłbym być lepszy bez definicji makra. Chociaż w końcu mi się udało, zajęło mi to trochę czasu!

Wymaga zestawu znaków hosta z kolejnymi literami (więc ASCII jest w porządku, ale EBCDIC nie działa). To dotyczy pary tabel odnośników. Wybrałem jjako znak zerowy i skorzystałem z potrzeby dwóch wyszukiwań, więc mogłem odjąć jedno od drugiego, zamiast odejmować moje zero od obu.

Skomentowana wersja:

char*i=
    "jmmonnmoon"                /* 0 to 9 */
    "mpprrqqsrr"                /* 10 to 19 */
    "jjddeeecdd";               /* tens */
char x;                /* current letter count */

f(n,c){
return
    !n?n                        /* zero - return 0 (ignore c) */
    :n<0?f(-n,8)                /* negative n (only reached if c==0) */
    :n<100?c+i[n<20?n:n%10]-i[20+n/10] /* lookup tables */
    :
      f(n/1000,8)               /* thousand */
    + f(n/100%10,7)             /* hundred */
    + f(n%100,0)                /* rest */
    + c;                        /* carry-in */
}
main(int c, char**v)
{
    for(c=atoi(*++v);c-4;c=x)
        printf("%d is %d and ",c,x=c?f(c,0):4);
    puts("4 is the magic number");
}

Istnieje oczywiste rozszerzenie, które obsługuje miliony, zastępując f(n/1000,8)je f(n/1000000,7)+f(n/1000%1000,8).

Wyjście testowe

0 is 4 and 4 is the magic number
1 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
2 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
3 is 5 and 5 is 4 and 4 is the magic number
4 is the magic number
5 is 4 and 4 is the magic number
6 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
7 is 5 and 5 is 4 and 4 is the magic number
8 is 5 and 5 is 4 and 4 is the magic number
9 is 4 and 4 is the magic number
10 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
17 is 9 and 9 is 4 and 4 is the magic number
100 is 10 and 10 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
142 is 18 and 18 is 8 and 8 is 5 and 5 is 4 and 4 is the magic number
1000 is 11 and 11 is 6 and 6 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
1642 is 29 and 29 is 10 and 10 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
70000 is 15 and 15 is 7 and 7 is 5 and 5 is 4 and 4 is the magic number
131072 is 37 and 37 is 11 and 11 is 6 and 6 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number
999999 is 50 and 50 is 5 and 5 is 4 and 4 is the magic number
Toby Speight
źródło
4

Mathematica, 156–30 = 126 bajtów

a=ToString;({a@#," is ",a@#2," and "}&@@@Partition[NestWhileList[#~IntegerName~"Words"~StringCount~LetterCharacter&,#,#!=4&],2,1])<>"4 is the magic number"&

Jestem po prostu zaskoczony, że to używa ciągów i nie jest absurdalnie długie.

LegionMammal978
źródło
4

Szybka 2 , 408 419 - 30 = 389 bajtów

Byłbym w stanie pozbyć się 176 bajtów, gdyby Swift nie był tak gadatliwy dzięki wyrażeniom regularnym (usuwającym myślniki i spacje) * patrzy na Apple *

func c(var s:Int)->String{var r="";while(s != 4){r+="\(s)";let f=NSNumberFormatter();f.numberStyle=NSNumberFormatterStyle.SpellOutStyle;let v=f.stringFromNumber(s)!;s=v.stringByReplacingOccurrencesOfString("[- ]",withString:"",options:NSStringCompareOptions.RegularExpressionSearch,range:Range<String.Index>(start:v.startIndex,end:v.endIndex)).utf8.count+(s<0 ?3:0);r+=" is \(s) and "};return r+"4 is the magic number"}

Można to przetestować na swiftstub.com tutaj

Uruchomiłem trochę pętli for i okazuje się, że 100003liczba od 0 do 999999 ma najdłuższy wynik ciągu, który ma 6 iteracji i jest

100003 to 23, a 23 to 11, a 11 to 6, a 6 to 3, a 3 to 5, a 5 to 4, a 4 to magiczna liczba

Nie golfił

func a(var s: Int) -> String{
    var r = ""
    while(s != 4){
        r+="\(s)"

        let f = NSNumberFormatter()
        f.numberStyle = NSNumberFormatterStyle.SpellOutStyle
        let v = f.stringFromNumber(s)!
        s = v.stringByReplacingOccurrencesOfString(
            "[- ]",
            withString: "",
            options: NSStringCompareOptions.RegularExpressionSearch,
            range: Range<String.Index>(start: v.startIndex, end: v.endIndex)
        ).utf8.count + (s < 0 ? 3 : 0)

        r+=" is \(s) and "
    }
    return r+"4 is the magic number"
}
Jojodmo
źródło
7
NSStringCompareOptions.RegularExpressionSearchI myślałem, że JS String.fromCharCodebyła pełna. : P
ETHproductions
4
Python i Ruby string.replace. Swift:String.stringByReplacingOccurrencesOfString
kot
4

Haskell, 285-180 = 105 bajtów

W rzeczywistości nie ma wbudowanej funkcji wyświetlania liczby. Nadal jestem niezadowolony z wyniku. Skomentuj. Będę jednak eksperymentował dalej. Mimo to wynik jest lepszy niż wynik Swifta

c n|n<0=8+c(-n)|n>999=r 1000+8|n>99=7+r 100|n>19=r 10+2-g[30..59]+g[20..29]|n>15=r 10-1|2>1=[0,3,3,5,4,4,3,5,5,4,3,6,6,8,8,7]!!n where{g=fromEnum.elem n;r k=c(mod n k)+c(div n k)}
m 4="4 is the magic number"
m 0="0 is 4 and "++m 4
m n=show n++" is "++show(c n)++" and "++m(c n)

stosowanie

m 7
"7 is 5 and 5 is 4 and 4 is the magic number"
m 999999
"999999 is 50 and 50 is 5 and 5 is 4 and 4 is the magic number"

Wyjaśnienie.

mjest dość trywialny, jednak cnie jest. cjest funkcją zliczającą liczbę znaków angielską nazwę liczby.

c n |n<0=8+c(-n) -- Add word "negative" in front of it, the length is 8
    |n>999=r 1000+8 -- the english name for number with form xxx,yyy is xxx thousand yyy
    |n>99=7+r 100 -- the english name for number with form xyy is x hundred yy
    |n>19=r 10+2-g[30..59]+g[20..29] -- the english name for number with form xy with x more
                                     -- than 1 is x-ty. However *twoty>twenty,
                                     -- *threety>thirty, *fourty>forty, *fivety>fifty.
    |n>10=r 10-1-g(15:18:[11..13]) -- the english name for number with form 1x is x-teen.
                                     -- However, *oneteen>eleven, *twoteen>twelve,
                                     -- *threeteen>thirteen, *fiveteen>fifteen,
                                     -- *eightteen>eighteen
    |2>1=[0,3,3,5,4,4,3,5,5,4,3]!!n -- for number 0-10, the length is memorized. 0 is 0
                                    -- because it is omitted. Input zero is handled
                                    -- separately. If we defined 0 to be 4, then
                                    -- 20 => twenty zero.
  where g   =fromEnum.elem n      -- Check if n is element of argument array, if true, 1 else 0
        r k=c(mod n k)+c(div n k) -- Obvious.
Akangka
źródło
1
O tak Cóż, Swift ma ... uhm ... wyższy wynik ... (Nie jestem zbyt dobry w
powrotach
4

C, 268 - 180 = 88 bajtów

#define t(x,o)n<x?o:f(n/x)+(n%x?f(n%x):0)
char*i="4335443554366887798866555766";f(n){return t(1000,t(100,n<20?n<0?8+f(-n):i[n]-48:i[n/10+18]-48+(n%10?f(n%10):0))+7)+8;}main(n){for(scanf("%d",&n);n^4;n=f(n))printf("%d is %d and ",n,f(n));puts("4 is the magic number");}

Wypróbuj tutaj .

Nie golfił

/* Encode number length in string (shorter representation than array) */
char*i="4335443554366887798866555766";

f(n)
{
    return n < 1000
        ? n < 100
            ? n < 20
                ? n < 0
                    ? 8 + f(-n) /* "Negative x" */
                    : i[n] - 48 /* "x" */
                : i[n/10+18] + (n%10 ? f(n%10) : 0) /* 20-99 */
            : f(n/100) + (n%100 ? f(n%100) : 0) + 7 /* x hundred y */
        : f(n/1000) + (n%1000 ? f(n%1000) : 0) + 8; /* x thousand y */
}

main(n)
{
    /* Keep printing until you get to the magic number */
    for(scanf("%d",&n);n^4;n=f(n))
        printf("%d is %d and ",n,f(n));
    puts("4 is the magic number");
}
Cole Cameron
źródło
3

Java, 800-150 = 650 bajtów

class G{static String e="",i="teen",j="ty",k="eigh",y="thir",d="zero",l="one",n="two",m="three",h="four",s="five",c="six",t="seven",b=k+"t",g="nine",D="ten",L="eleven",N="twelve",M=y+i,H=h+i,S="fif"+i,C=c+i,T=t+i,B=k+i,G=g+i,o="twen"+j,p=y+j,q="for"+j,r="fif"+j,u=c+j,v=t+j,w=k+j,x=g+j,A=" ",O=" hundred ",z,E;public static void main(String a[]){z=e;int l=new Integer(a[0]);do{E=a(l,1,e);l=E.replace(A,e).length();z=z+E+" is "+a(l,1,e)+" and ";}while(l!=4);System.out.print(z+h+" is the magic number");}static String a(int P,int _,String Q){String[]f={e,l,n,m,h,s,c,t,b,g,D,L,N,M,H,S,C,T,B,G,e,D,o,p,q,r,u,v,w,x};int R=20,X=10,Y=100,Z=1000;return P==0?(_>0?d:e):(P<R?f[P]+Q:(P<Y?(f[R+(P/X)]+" "+a(P%X,0,e)).trim()+Q:(P<Z?a(P/Y,0,O)+a(P%Y,0,e)+Q:a(P/Z,0," thousand ")+a((P/Y)%X,0,O)+a(P%Y,0,e)+Q)));}}

Grał w golfa

class G {

   static String e="",i="teen",j="ty",k="eigh",y="thir",d="zero",l="one",n="two",m="three",h="four",s="five",c="six",t="seven",b=k+"t",g="nine",D="ten",L="eleven",N="twelve",M=y+i,H=h+i,S="fif"+i,C=c+i,T=t+i,B=k+i,G=g+i,o="twen"+j,p=y+j,q="for"+j,r="fif"+j,u=c+j,v=t+j,w=k+j,x=g+j,A=" ",O=" hundred ",z,E;

   public static void main(String a[]){
     z = e;
     int l = new Integer(a[0]);
     do {
             E = a(l,1,e);
             l = E.replace(A,e).length();  
             z = z+E+" is "+a(l,1,e)+" and ";
     } while(l!=4);
     System.out.println(z+h+" is the magic number");
   }

   static String a(int P,int _,String Q) {
     String[] f = {e,l,n,m,h,s,c,t,b,g,D,L,N,M,H,S,C,T,B,G,e,D,o,p,q,r,u,v,w,x};
     int R=20,X=10,Y=100,Z=1000;
     return P==0?(_>0?d:e):(P<R?f[P]+Q:(P<Y?(f[R+(P/X)]+" "+a(P%X,0,e)).trim()+Q:(P<Z?a(P/Y,0,O)+a(P%Y,0,e)+Q:a(P/Z,0," thousand ")+ a((P/Y)%X,0,O)+a(P%Y,0,e)+Q)));
   }
}
Minimalny
źródło
Wiem, że minął już ponad rok, ale możesz usunąć nawiasy w tym trójstronnym zadaniu, a także zmienić ==0na <1. Tak więc: return P<1?_>0?d:e:P<R?f[P]+Q:P<Y?(f[R+(P/X)]+" "+a(P%X,0,e)).trim()+Q:P<Z?a(P/Y,0,O)+a(P%Y,0,e)+Q:a(P/Z,0," thousand ")+a((P/Y)%X,0,O)+a(P%Y,0,e)+Q;( - 10 bajtów )
Kevin Cruijssen
3

QC, 265–30–150 = 85 bajtów

(✵1:oaT%=ta100%=ha100/⌋T%=X[0 3 3 5 4 4 3 5 5 4 3 6 6 8 8 7 7 9 8 8]=Y[6 6 5 5 5 7 6 6]=a0≟4a20<Xt☌YtT/⌋2-☌Xo☌+▲▲hXh☌7+0▲+)(❆1:na0<8*=ba‖1000/⌋=ca1000%=nbb✵8+0▲a✵++){I4≠:EEI" is "++=II❆=EEI" and "++=E!}E"4 is the magic number"+

Zestaw testowy

Nie golfowany:

(✵1:
oaT%=                                        # ones
ta100%=                                      # tens
ha100/⌋T%=                                   # hundreds
X[0 3 3 5 4 4 3 5 5 4 3 6 6 8 8 7 7 9 8 8]=  # length of "zero", "one", "two", ..., "nineteen"
Y[6 6 5 5 5 7 6 6]=                          # length of "twenty", ..., "ninety"
a0≟
  4
  a20< 
    Xt☌ 
    YtT/⌋2-☌ Xo☌ +
  ▲ 
▲
hXh☌7+0▲+)

(❆1:
na0<8*=                 # if negative, add 8
ba‖1000/⌋=              # split aaaaaa into bbbccc
ca1000%=
n bb✵8+0▲ a✵ ++)

{I4≠:EEI" is "++=II❆=EEI" and "++=E!}E"4 is the magic number"+
Avris
źródło
Jeśli nie używasz wbudowanej funkcji do uzyskania długości liczby, więc możesz odjąć kolejne 150 od swojego wyniku
Jojodmo
2

JavaScript, 382–150–30 = 202 bajty

var o=[0,3,3,5,4,4,3,5,5,4],f=s=>(s[1]==1?[3,6,6,8,8,7,7,9,8,8][s[0]]:o[s[0]]+(s.length>1?[0,3,6,6,5,5,5,7,6,6][s[1]]:0))+(s.length==3?(7+o[s[2]]-(o[s[2]]==0?7:0)):0),l=n=>{var s=(""+n).split("").reverse();return f(s.slice(0,3))+(s.length>3?(f(s.slice(3,6))+8):0)};(n=>{var s="";while(n!=4){s+=n+" is ";n=n>=0?l(n):(l(-n)+8);s+=n+" and ";}console.log(s+"4 is the magic number");})()

Dane wejściowe podano jako parametr do wyrażenia funkcji natychmiast wywołanego.

Wejście testowe:

999999 ->
    999999 is 50 and 50 is 5 and 5 is 4 and 4 is the magic number
17 ->
    17  is 9 and 9 is 4 and 4 is the magic number
-404 ->
    -404 is 23 and 23 is 11 and 11 is 6 and 6 is 3 and 3 is 5 and 5 is 4 and 4 is the magic number

Gra w golfa:

// array of the lengths of digits in ones place:
// one is 3, two is 3, three is 5, etc... zero is a special case
// and is assigned zero length because zero is never written out in a number name
var o=[0,3,3,5,4,4,3,5,5,4],

// function that computes the length of a substring of the input
// because the input is 6 digits, it can be broken into two 3 digit subsections
// each of which can have it's length calculated separately
f=s=>
  (
  s[1]==1? // check for if the tens digit is a one
    // when the tens is a one, pull the string length from an array that represents
    // ten, eleven, twelve, thirteen, etc...
    [3,6,6,8,8,7,7,9,8,8][s[0]]
  :
    // when the tens digit is not a one, add the ones digit normally and...
    o[s[0]]
    +
    // add the tens digit length from the array that represents
    // zero, ten, twenty, thirty, forty, fifty, sixty, seventy, eighty, ninety
    (s.length>1?[0,3,6,6,5,5,5,7,6,6][s[1]]:0)
  )
  +
  (
  s.length==3? // check if the length is 3 and weren't not accidentally trying to do something wierd with a minus sign
    // if so, then we have to add a hundred (7 characters) to the length and the
    // length of the ones digit that is in the hundreds place like
    // 'one' hundred or 'two' hundred
    (7+o[s[2]]-
      (
        // also, if the hundreds place was a zero, subtract out those 7 characters
        // that were added because 'hundred' isn't added if there's a zero in its
        // place
        o[s[2]]==0?
          7
        :
          0
      )
    )
  :
    // if the length wasn't 3, then don't add anything for the hundred
    0
  ),

// function that computes the length of the whole six digit number
l=n=>{
  // coerce the number into a string and then reverse the string so that the
  // ones digit is the zeroth element instead of last element
  var s=(""+n).split("").reverse();
  return
    // calculate the character length of the first 3 characters
    // like in the number 999888, this does the '888'
    f(s.slice(0,3))
    +
    // then if there actually are any characters after the first 3
    (s.length>3?
        // parse the character length of the second 3 characters
        (f(s.slice(3,6))+8)
      :
        0
    )
};
// lastly is the Immediately-Invoked Function Expression
(n=>{
  var s="";
  // as long as we haven't reached four, just keep going through the loop
  while(n!=4){
    s+=n+" is ";
    n=n>=0?l(n):(l(-n)+8) // this handles negatives by only passing positive values to l and then just adding 8 onto the length for negatives
    s+=n+" and ";
  }
  // finally just say that '4 is the magic number'
  console.log(s+"4 is the magic number");
})(999999)
Davis
źródło
1

Python 641-150 = 501 bajtów

Przynajmniej nie jest dłuższy niż Java! Opiera się na tym, z wyjątkiem używania ciągów.

EDYCJA : Zapomniałem o 0 i muszę powiedzieć „5 to 4”, a nie przeskocz do „4 to magiczna liczba” - to trochę poprawiło wynik. 

w={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"}
s=""
def i(n):
 global s
 e=""
 o=n%10
 t=n%100
 h=n/100%10
 th=n/1000
 if th:
  e+=i(th)
  e+='thousand'
 if h:
  e+=w[h]
  e+='hundred'
 if t:
  if t<20 or o==0:
   e+=w[t]
  else:
   e+=w[t-o]
   e+=w[o]
 if len(e)==4:s+="4 is the magic number";print s
 else: s+="%d is %d and "%(n,len(e));i(len(e))
In=input()
i(In)

Wypróbuj tutaj!

TanMath
źródło
Nie musisz wyświetlać nazwy, prawda?
Akangka
To jest niepoprawne. i(5)drukuje 4 is the magic numberzamiast 5 is 4 and 4 is the magic number.
mbomb007
1

Moo, 182 176/ 192 188 bajtów - 30 = 146/158

Wersja 188 bajtów:

u=$string_utils;s="";i=args[0];while(i-4)j=u:english_number(i);s=s+j+(s?" and "+j|"")+" is ";i=length(u:strip_chars(j,"- "}));endwhile;return s+(s?"four and "|"")+"four is the magic number"

176-bajtowa wersja zależna od implementacji :

s="";i=args[0];while(i-4)j=#20:english_number(i);s=s+j+(s?" and "+j|"")+" is ";i=length(#20:strip_chars(j," -"));endwhile;return s+(s?"four and "|"")+"four is the magic number"

Obie są funkcjami.

pppery
źródło
1

PHP, 168–30 = 138 bajtów

function m($i){$e=strlen(preg_replace('/[^a-z-]/','',(new NumberFormatter("en",5))->format($i)));echo($i==$e?"":"$i is $e and "),($e==4?"4 is the magic number":m($e));}
Jonathan Moyes
źródło