Quatre est le nombre magique

26

Je n'ai pas vérifié le bac à sable avant de publier ce défi - il semble que ce défi ait été proposé par Cᴏɴᴏʀ O'Bʀɪᴇɴ .

Étant donné une entrée entière, écrivez un programme qui imprime l'énigme "quatre est un nombre magique"

  • Quatre est le nombre magique
  • Cinq est quatre et quatre est le nombre magique
  • Six est trois et trois est cinq et cinq est quatre et quatre est le nombre magique
  • Onze est six et six est trois et trois est cinq et cinq est quatre et quatre est le nombre magique
  • Cinq cent est onze et onze est six et six est trois et trois est cinq et cinq est quatre et quatre est le nombre magique

Si vous connaissez déjà l'énigme, ou si vous êtes trop paresseux pour la résoudre, impatient de savoir ce qu'est l'énigme, voici une explication

Le chiffre suivant est le nombre de lettres du chiffre précédent. Ainsi, par exemple, cinq a quatre lettres, donc le chiffre suivant est quatre .

six a trois lettres, donc le chiffre suivant est 3 , et trois a cinq lettres, donc le chiffre suivant est 5 , et cinq a quatre lettres, donc le chiffre suivant est 4

La raison pour laquelle l'énigme se termine à quatre est parce que quatre a quatre lettres et quatre est quatre et quatre est quatre et quatre est quatre ... (quatre est le nombre magique)

Cas de 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

Règles

  • L'entrée peut être extraite STDINou comme argument d'une fonction
  • L'entrée sera un nombre positif compris entre 0 et 999 999
  • L'entrée ne contiendra que des nombres (elle suivra l'expression régulière ^[0-9]+$)
  • L'entrée peut être considérée comme un entier ou une chaîne
  • Lorsqu'ils sont convertis en chaîne de mots, les espaces et les tirets ne doivent pas être inclus dans le décompte (100 [cent] correspond à 10 caractères, pas 11. 1 742 [mille sept cent quarante-deux] correspond à 31 caractères, pas 36)
  • Une fois converti en chaîne, 100 doit être Cent, pas Cent ou Cent, 1000 doit être Mille, pas Mille ou Mille.
  • Une fois converti en une chaîne 142 devrait être cent quarante deux, pas cent et quarante deux
  • La sortie ne respecte pas la casse et doit suivre le format " N est K et K est M et M est ... et quatre est le nombre magique" (sauf si l'entrée est 4, auquel cas la sortie doit simplement être "quatre est le nombre magique ")
  • La sortie peut utiliser des nombres au lieu de lettres ("5 est 4 et 4 est le nombre magique" au lieu de "cinq est quatre et quatre est le nombre magique") tant que votre programme est toujours cohérent
  • La sortie peut être soit la valeur de retour d'une fonction, soit imprimée sur STDOUT
  • Des échappatoires standard s'appliquent
  • Il s'agit de code-golf , donc le programme le plus court en octets l'emporte. Bonne chance!

Prime

-30 octets si le programme fonctionne lorsque l'entrée est comprise entre -999 999 et 999 999.

Les nombres négatifs, lorsqu'ils sont convertis en mots, ont juste "négatif" devant eux. Par exemple, -4"Negative Four", Negative Four est douze et douze est six et six est trois et trois est cinq et cinq est quatre et quatre est le nombre magique

-150 octets si le programme n'utilise aucune fonction intégrée pour générer la représentation sous forme de chaîne du nombre

Classement

Il s'agit d'un extrait de pile qui génère à la fois un classement et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre en utilisant le modèle Markdown suivant

## Language Name, N bytes

Où N est la taille, en octets, de votre soumission

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, en supprimant les anciens scores ou en incluant des indicateurs dans le nombre d'octets), assurez-vous simplement que le score réel est le dernier numéro de votre en-tête

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

Afficher l'extrait de code

code-golf  number 
— Jojodmo
source
Y a-t-il une entrée maximale possible?
— Arcturus
7
À l'avenir, veuillez également vérifier le bac à sable pour voir si quelqu'un d'autre a eu votre idée .
— El'endia Starman
@ El'endiaStarman Très bien, j'ai ajouté du texte en haut du défi
— lié
Votre bonus de fonction intégré devrait être plus proche de -150 à -200 octets.
— TanMath
1
Je vais juste jeter ça là-bas - même le nombre le plus incroyablement optimisé pour convertir les noms va à peine coûter moins de 150 octets pour la plupart des langues, car il se trouve que le -150 est plus un piège qu'un bonus.
— ricdesi

Réponses:

9

Bash + utilitaires communs (y compris les jeux bsd), 123 - 30 = 93 octets

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

Heureusement, la sortie de l' utilitaire bsd-gamesnumber est presque exactement ce dont nous avons besoin. Les numéros de sortie sont tous écrits numériquement et non pas en mots selon le 8ème point:

$ ./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
$
— Traumatisme numérique
source
6

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

Inspiré par la réponse de Cole Cameron . Je pensais que je pourrais faire mieux sans la définition de macro. Bien que j'ai finalement réussi, il a fallu un peu de compression pour y parvenir!

Il nécessite un jeu de caractères hôte avec des lettres consécutives (donc ASCII est correct, mais EBCDIC ne fonctionnera pas). C'est pour la paire de tables de recherche. J'ai choisi jle caractère zéro et j'ai profité d'avoir besoin de deux recherches pour pouvoir soustraire l'une de l'autre plutôt que d'avoir à soustraire mon zéro des deux.

Version commentée:

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

Il y a une extension évidente pour supporter des millions, en remplaçant f(n/1000,8)par f(n/1000000,7)+f(n/1000%1000,8).

Sortie test

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

Mathematica, 156-30 = 126 octets

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

Je suis simplement surpris que cela utilise des cordes et ne soit pas ridiculement long.

— LegionMammal978
source
4

Swift 2 , 408 419 - 30 = 389 octets

Je serais en mesure de me débarrasser de 176 octets si Swift n'était pas aussi verbeux avec des expressions régulières (suppression des tirets et des espaces) * lance un regard noir à 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"}

Cela peut être testé sur swiftstub.com, ici

J'ai couru un peu pour la boucle, et il s'avère que 100003le nombre compris entre 0 et 999999 a le résultat de chaîne le plus long, qui a 6 itérations, et est

100003 est 23 et 23 est 11 et 11 est 6 et 6 est 3 et 3 est 5 et 5 est 4 et 4 est le nombre magique

Non golfé

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
source
7
NSStringCompareOptions.RegularExpressionSearchEt je pensais que JS String.fromCharCodeétait verbeux. : P
— ETHproductions
4
Python et Ruby: string.replace. Swift:String.stringByReplacingOccurrencesOfString
— cat
4

Haskell, 285 - 180 = 105 octets

En fait, il n'y a pas du tout intégré pour afficher le nombre. Je n'étais toujours pas satisfait du score. N'hésitez pas à commenter. Je vais expérimenter plus loin, cependant. Le score est toujours meilleur que le score de 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)

usage

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"

Explication.

mest assez banal, cependant, ce cn'est pas le cas. cest la fonction pour compter le nombre de caractères du nom anglais du numéro.

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
source
1
Oh oui? Eh bien, Swift a ... euh ... un score plus élevé ... (je ne suis pas très bon pour les retours)
— Jojodmo
4

C, 268 - 180 = 88 octets

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

Essayez-le ici .

Non golfé

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

Java, 800 - 150 = 650 octets

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-golfé

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)));
   }
}
— Minimal
source
Je sais que cela fait plus d'un an, mais vous pouvez supprimer certaines parenthèses dans cette affectation ternaire ainsi que passer ==0à <1. Donc: 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 octets )
— Kevin Cruijssen
3

QC, 265-30-150 = 85 octets

(✵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 de tests

Non golfé:

(✵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
source
Si vous n'utilisez pas de fonction intégrée pour obtenir la longueur du nombre, vous pouvez donc réellement soustraire 150 autres de votre score
— Jojodmo
2

JavaScript, 382 - 150 - 30 = 202 octets

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'entrée est donnée comme paramètre à l'expression de fonction immédiatement invoquée.

Entrée de test:

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-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
source
1

Python 641-150 = 501 octets

Au moins, ce n'est pas plus long que Java! Il est basé sur cela, sauf en utilisant des chaînes.

EDIT : J'ai oublié 0 et que je dois dire "5 est 4", ne pas passer à "4 est le nombre magique" - qui a ajouté un peu au score. 

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)

Essayez-le ici!

— TanMath
source
Vous n'avez pas à afficher le nom, non?
— Akangka
Ceci est une erreur. i(5)imprime 4 is the magic number, au lieu de 5 is 4 and 4 is the magic number.
— mbomb007
1

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

Version 188 octets:

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"

Version dépendante de l'implémentation de 176 octets :

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"

Les deux sont des fonctions.

— pppery
source
1

PHP, 168-30 = 138 octets

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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.