A l'origine la racine numérique multiplicative
Défi
Faites essentiellement ce que dit le titre
Méthode
Étant donné un entier positif 1 <= N <= 100000000 via l'une de nos méthodes de saisie standard , multipliez chaque chiffre ensemble, en ignorant les zéros.
Ex: Prenez un nombre, dites 361218402
:
3
*6
=18
18
*1
=18
18
*2
=36
36
*1
=36
36
*8
=288
288
*4
=1152
1152
*1
(ignorez les zéros ou transformez-les en uns) =1152
1152
*2
=2304
La sortie pour 361218402
est2304
Cas de test
1 => 1 tous les deux chiffres> 0 => lui-même 10 => 1 20 => 2 100 => 1 999 => 729 21333 => 54 17801 => 56 4969279 => 244944 100000000 => 1
Les échappatoires standard ne sont pas autorisées, et il s'agit de code-golf , donc le nombre d'octets le plus court gagne!
Félicitations à Jo King qui a obtenu la prime avec sa réponse de 70 octets brain-flak!
code-golf
math
arithmetic
integer
FantaC
la source
la source
100000000000
je suggère le cas de test99999999999 => 31381059609
, car il ne tient pas dans un entier 32 bits par défaut. Il serait peut-être préférable de réduire la sortie maximale à un maximum de 32 bits (2147483647).Réponses:
Pyt , 3 octets
Explication:
Essayez-le en ligne!
la source
Haskell , 27 octets
Essayez-le en ligne!
Ungolfed avec UniHaskell et
-XUnicodeSyntax
Explication
Je vais commencer par ce que j'avais initialement:
Il s'agit d'une expression sans point qui évalue une fonction en prenant une chaîne (ou une liste de caractères) s (
"301"
) comme argument. Il mappemax 1.read.pure
sur s , prenant essentiellement chaque caractère i , l'injectant dans une liste (ce qui en fait une chaîne) (["3", "0", "1"]
), puis le lisant, qui évalue la chaîne ([3, 0, 1]
) et finalement prenant le plus grand de i et 1 ([3, 1, 1]
). Ensuite, il prend laproduct
de la liste résultante d'entiers (3
).Je l'ai ensuite joué au golf d'un octet avec:
Cela fonctionne car
product
est équivalent àfoldr (*) 1
. Au lieu de mapper et de plier, j'ai combiné les deux en pliant avec(*).max 1.read.pure
lequel prend chaque chiffre non nul et le multiplie par l'accumulateur.la source
Python 2 , 34 octets
Essayez-le en ligne!
la source
Gelée , 4 octets
Essayez-le en ligne! ou voir la suite de tests
Comment ça marche
la source
R , 40 octets
Essayez-le en ligne!
Étant donné que l'entrée ne peut pas contenir plus de 12 chiffres, cela devrait fonctionner correctement. Calcule les chiffres comme
x
(y compris les zéros non significatifs), puis remplace les zéros par1
et calcule le produit.la source
C (gcc) , 39 octets
Doit être compilé sans optimisations (qui est de toute façon le paramètre par défaut pour gcc).
Essayez-le en ligne!
la source
k=k;
mettrek
accidentellement dans le registre de retour est tout simplement mauvais. Vous devriez probablement ajouter que cela ne fonctionne que sans optimisation sur éventuellement seulement x86 / x64. +1.O0
) n'est la valeur par défaut pour gcc, il n'est donc pas nécessaire d'utiliser explicitement cet indicateur. Je suppose que j'en ajouterai une mention de toute façon.Brain-Flak ,
747270 octets-2 merci à Nitrodon pour avoir suggéré d'obtenir la négation du nombre afin que vous n'ayez qu'à augmenter plutôt qu'à décrémenter plus tard
Essayez-le en ligne!
Il peut y avoir plusieurs façons de jouer plus loin, comme
refaire la multiplication pour éviter d'avoir à initialiser le total avec 1.(-2 octets)Comment ça marche:
la source
05AB1E , 4 octets
Essayez-le en ligne!
Explication
la source
J ,
171413 octets-4 octets avec l'aimable autorisation de @GalenIvanov
Essayez-le en ligne!
Peut probablement être amélioré certains. Edit: et il en fut ainsi.
Explication
&.
-under est un adverbe astucieux qui applique le verbe à droite, puis le verbe à gauche, puis l' inverse du verbe à droite. La reconversion en nombres utilise également eval (".
-do).la source
+0=]
en*#]
Essayer en ligne[:*/0-.~,.&.":
pour 14 octets. Essayez-le en ligne(+-.@*)
, je suppose que je suis enclin à ajouter. J'avais essayé d'utiliser en'0'-.~
supposant une entrée d'une chaîne, je ne sais pas pourquoi cela ne me venait pas à l'esprit de le faire sur les chiffres fractionnés. Merci!1>.
fait le travail de0-.~
pour un octet de moins.[:*/1>.,.&.":
Essayez!Python 2 , 43 octets
Essayez-le en ligne!
la source
JavaScript (ES6), 28 octets
Conçu pour les entiers 32 bits.
Cas de test
Afficher l'extrait de code
la source
Bash + coreutils + sed + bc,
272423 octetsEssayez-le en ligne!
la source
Brachylog , 5 octets
Essayez-le en ligne!
Explication
Cela fonctionne parce que l'
⊇
unification des grands sous-ensembles aux petits sous-ensembles, donc le premier qui se traduira par un produit non nul est lorsque tous les zéros sont exclus et rien d'autre.la source
Perl 5 , 23 + 1 (
-p
) = 24 octetsEssayez-le en ligne!
la source
Java 8,
55545351 octetsRéponse de Python 2 du port de @Dennis .
-1 octet grâce à @RiaD .
Essayez-le ici.
55Version 54 octets:Essayez-le en ligne.
la source
long f(long n){return n>0?(n%10>0?n%10:1)*f(n/10):1;}
Julia 0,6, 26 octets
Exemple d'utilisation:
Essayez-le en ligne!
la source
JavaScript (Node.js) , 30 octets
Essayez-le en ligne!
Prend la chaîne en entrée, la traite comme un tableau et, par la déstructuration du tableau, sépare le premier élément
[a,...b]
.+a||1
renvoie le chiffre correspondant aua
caractère. Je suppose que le repos s'explique de lui-même ..la source
Octave , 21 octets
Merci à @Luis Mendo d'avoir enregistré un octet et merci à @alephalpha d'avoir enregistré un autre octet!
Prend l'entrée sous la forme d'une chaîne de chiffres.
Essayez-le en ligne!
30 octets:
Prend l'entrée sous forme de nombre.
Essayez-le en ligne!
la source
@(n)prod((k=n-48)+~k)
Brain-Flak , 88 octets
Version lisible:
Essayez-le en ligne!
la source
Clojure , 56 octets
Assez basique. Transforme le nombre en une chaîne, puis soustrait 48 de chaque caractère pour les reconvertir en nombres. Il remplace ensuite chaque 0 par un 1 et s'applique
*
à la liste de nombres résultante (qui se réduit*
sur la liste). Peut accepter un nombre ou un nombre stratifié.Essayez-le en ligne!
la source
MATL , 5 octets
L'entrée est considérée comme une chaîne
Essayez-le sur MATL Online! Ou vérifiez les cas de test dans Try It Online!
Explication
la source
Befunge,
2322 octetsEssayez-le en ligne!
Explication
la source
JavaScript (Node.js) ,
3633 octetsMéthode Javascript simple (ES6) qui prend l'entrée en tant que chaîne numérique, la diffuse dans un tableau, puis la réduit par multiplication ou renvoie la valeur si le résultat est 0.
3 octets économisés grâce à Shaggy
Essayez-le en ligne!
la source
Rubis,
4240353227 octetsNe suppose aucune nouvelle ligne dans l'entrée Influence majeure
-2 octets grâce à @GolfWolf
-5 octets grâce à @Conor O'Brien
la source
tr
: 32 octets*
pour rejoindre?p eval (gets.chars-[?0])*?*
?Java (OpenJDK 8) , 45 octets
Essayez-le en ligne!
la source
C # , 97 octets (premier code de golf)
Je ne sais pas si je devais l'envelopper dans une méthode ou pas, alors il suffit de l'inclure pour être en sécurité.
Prend un Int dans, le convertit en chaîne et retourne le multiple de chacun des caractères en ignorant les 0. Dû à moins 48 en raison du programme utilisant la valeur ascii car il la lit comme un caractère.
la source
var z=y.ToString();
et le placer directement dans leforeach
, comme ceciforeach(var q in y.ToString())
:; et pour obtenir le résultat, vous pouvez économiser plus d'octets en les remplaçant{if(q!=48){r*=q-48;}}
parr*=(q>48?q:1);
, en rasant les crochets et leif
.C # (Visual C # Interactive Compiler) , 46 octets
Essayez-le en ligne!
la source
Haskell , 36 octets
Même nombre d'octets:
Essayez-le en ligne!
la source
Gelée ,
6, 5 octetsEssayez-le en ligne!
la source
DTịDP
permettrait d'économiser un octet, mais il existe de meilleures façons de supprimer les zéros ou de les remplacer par autre chose.> <> , 19 octets
Essayez-le en ligne!
la source