Quattro è il numero magico

26

Non ho controllato la sandbox prima di pubblicare questa sfida - sembra che questa sfida sia stata proposta da Cᴏɴᴏʀ O'Bʀɪᴇɴ .

Dato un input intero, scrivi un programma che stampa l'indovinello "quattro è un numero magico"

  • Quattro è il numero magico
  • Cinque è quattro e quattro è il numero magico
  • Sei è tre e tre è cinque e cinque è quattro e quattro è il numero magico
  • Undici è sei e sei è tre e tre è cinque e cinque è quattro e quattro è il numero magico
  • Cinquecento è undici e undici sono sei e sei è tre e tre è cinque e cinque è quattro e quattro è il numero magico

Se conosci già l'enigma o sei troppo pigro per risolverlo ansioso di scoprire qual è l'enigma, ecco una spiegazione

Il numero successivo è il numero di lettere nel numero precedente. Quindi, ad esempio, cinque ha quattro lettere, quindi il numero successivo è quattro .

sei ha tre lettere, quindi il numero successivo è 3 e tre ha cinque lettere, quindi il numero successivo è 5 e cinque ha quattro lettere, quindi il numero successivo è 4

Il motivo per cui l'indovinello termina a quattro è perché quattro ha quattro lettere e quattro è quattro e quattro è quattro e quattro è quattro ... (quattro è il numero magico)

Casi test

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

Regole

  • L'input può essere preso da STDINo come argomento di una funzione
  • L'ingresso sarà un numero positivo compreso tra 0 e 999.999
  • L'input conterrà solo numeri (seguirà la regex ^[0-9]+$)
  • L'input può essere preso come numero intero o come stringa
  • Quando convertiti in una stringa di parole, gli spazi e i trattini non devono essere inclusi nel conteggio (100 [Cento] è 10 caratteri, non 11. 1,742 [Mille settecentoquarantadue] è 31 caratteri, non 36)
  • Quando convertito in una stringa, 100 dovrebbe essere Cento, non Cento o Cento, 1000 dovrebbero essere Mille, non Mille o Mille.
  • Quando convertito in una stringa 142 dovrebbe essere centoquaranta due, non cento e Forty Two
  • L'output non fa distinzione tra maiuscole e minuscole e dovrebbe seguire il formato " N è K e K è M e M è ... e quattro è il numero magico" (a meno che l'ingresso sia 4, nel qual caso l'output dovrebbe essere semplicemente "quattro è il numero magico ")
  • L'output può utilizzare numeri anziché lettere ("5 è 4 e 4 è il numero magico" anziché "cinque è quattro e quattro è il numero magico") purché il programma sia sempre coerente
  • L'output può essere il valore di ritorno di una funzione o essere stampato su STDOUT
  • Si applicano scappatoie standard
  • Questo è code-golf , quindi vince il programma più breve in byte. In bocca al lupo!

indennità

-30 byte se il programma funziona quando l'input è compreso tra -999.999 e 999.999.

I numeri negativi, quando convertiti in parole, hanno solo "negativo" davanti a loro. Ad esempio -4è "Negativo quattro", Negativo quattro è dodici e dodici è sei e sei è tre e tre è cinque e cinque è quattro e quattro è il numero magico

-150 byte se il programma non utilizza alcuna funzione integrata per generare la rappresentazione in forma di stringa del numero

Classifica

Questo è un frammento di stack che genera sia una classifica che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, inizia la tua risposta con un titolo usando il seguente modello Markdown

## Language Name, N bytes

Dove N è la dimensione, in byte, dell'invio

Se vuoi includere più numeri nella tua intestazione (ad esempio, colpendo i vecchi punteggi o includendo i flag nel conteggio dei byte), assicurati solo che il punteggio effettivo sia l' ultimo numero nella tua intestazione

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

Mostra snippet di codice

code-golf  number 
— Jojodmo
fonte
C'è un input massimo possibile?
— Arcturus,
7
In futuro, controlla anche il Sandbox per vedere se qualcun altro ha avuto la tua idea .
— El'endia Starman il
@ El'endiaStarman Va bene, ho aggiunto del testo all'inizio della sfida che collega a quel post
— Jojodmo,
Il bonus della funzione integrata dovrebbe essere più simile a -150 a -200 byte.
— TanMath,
1
Lo lancerò là fuori - anche il numero più follemente ottimizzato di convertitori di nomi costa a malapena meno di 150 byte per la maggior parte delle lingue, dato che il -150 è più una trappola che un bonus.
— Ricdesi,

Risposte:

9

Bash + utility comuni (compresi i giochi bsd), 123-30 = 93 byte

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

Per fortuna l'uscita dal BSD-giochi numberutilità è quasi esattamente quello che ci serve. I numeri di output sono tutti scritti numericamente e non in parole come dall'ottavo punto elenco:

$ ./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
$
— Trauma digitale
fonte
6

C, 263 261 byte - 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");}

Ispirato dalla risposta di Cole Cameron . Pensavo di poter fare di meglio senza la definizione macro. Anche se alla fine ci sono riuscito, ci sono voluti alcuni spremuti per raggiungere!

Richiede un set di caratteri host con lettere consecutive (quindi ASCII va bene, ma EBCDIC non funzionerà). Questo è per la coppia di tabelle di ricerca. Ho scelto jil carattere zero e ho approfittato della necessità di due ricerche, in modo da poter sottrarre l'una dall'altra invece di dover sottrarre il mio zero da entrambe.

Versione commentata:

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");
}

C'è un'estensione ovvia per supportare milioni, sostituendola f(n/1000,8)con f(n/1000000,7)+f(n/1000%1000,8).

Uscita di prova

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
fonte
4

Mathematica, 156-30 = 126 byte

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

Sono semplicemente sorpreso che questo usi stringhe e non sia ridicolmente lungo.

— LegionMammal978
fonte
4

Swift 2 , 408 419-30 = 389 byte

Sarei in grado di liberarmi di 176 byte se Swift non fosse così prolisso con espressioni regolari (rimozione di trattini e spazi) * riflessi su 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"}

Questo può essere testato su swiftstub.com, qui

Ho eseguito un po 'per il ciclo, e risulta che 100003il numero tra 0 e 999999 ha il risultato di stringa più lungo, che ha 6 iterazioni, ed è

100003 è 23 e 23 è 11 e 11 è 6 e 6 è 3 e 3 è 5 e 5 è 4 e 4 è il numero magico

Ungolfed

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
fonte
7
NSStringCompareOptions.RegularExpressionSearchE ho pensato che JS String.fromCharCodefosse prolisso. : P
— Produzioni ETH il
4
Python e Ruby: string.replace. Swift:String.stringByReplacingOccurrencesOfString
— cat
4

Haskell, 285-180 = 105 byte

In effetti, non è presente alcun built-in per la visualizzazione del numero. Non sono ancora soddisfatto del punteggio. Sentiti libero di commentare. Sperimenterò ulteriormente, però. Il punteggio è comunque migliore del punteggio di Swift

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)

uso

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"

Spiegazione.

mè abbastanza banale, tuttavia, non lo cè. cè la funzione per contare il numero di caratteri il nome inglese del numero.

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
fonte
1
Oh si? Bene, Swift ha ... uhm ... un punteggio più alto ... (Non sono molto bravo nei ritorni)
— Jojodmo,
4

C, 268-180 = 88 byte

#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");}

Provalo qui .

Ungolfed

/* 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
fonte
3

Java, 800-150 = 650 byte

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

De-golfed

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)));
   }
}
— Minimo
fonte
So che è passato più di un anno, ma puoi rimuovere alcune parentesi in quell'incarico ternario e passare ==0a <1. Quindi: 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 byte )
— Kevin Cruijssen,
3

QC, 265-30-150 = 85 byte

(✵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"+

Suite di test

Ungolfed:

(✵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
fonte
Se non stai usando una funzione integrata per ottenere la lunghezza del numero, puoi effettivamente sottrarre altri 150 dal tuo punteggio
— Jojodmo
2

JavaScript, 382-150-30 = 202 byte

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");})()

L'input viene dato come parametro all'espressione di funzione immediatamente richiamata.

Test input:

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

De-giocato a golf:

// 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
fonte
1

Python 641-150 = 501 byte

Almeno non è più lungo di Java! Si basa su questo ad eccezione dell'uso delle stringhe.

EDIT : ho dimenticato di 0 e che devo dire "5 è 4", non saltare a "4 è il numero magico" - che ha aggiunto un po 'al punteggio. 

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)

Provalo qui!

— TanMath
fonte
Non devi visualizzare il nome, giusto?
— Akangka,
Questo non è corretto i(5)stampe 4 is the magic number, invece di 5 is 4 and 4 is the magic number.
— mbomb007,
1

Moo, 182 176/ 192 188 byte - 30 = 146/158

Versione a 188 byte:

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"

Versione dipendente dall'implementazione di 176 byte :

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"

Entrambe sono funzioni.

— pppery
fonte
1

PHP, 168-30 = 138 byte

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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.