^{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 361218402est2304

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!

Pyt , 3 octets

ąžΠ

Explication:

ą       Convert input to array of digits (implicit input as stack is empty)
 ž      Remove all zeroes from the array
  Π     Get the product of the elements of the array

Essayez-le en ligne!

Haskell , 27 octets

foldr((*).max 1.read.pure)1

Essayez-le en ligne!

Ungolfed avec UniHaskell et-XUnicodeSyntax

import UniHaskell

f ∷ String → Int
f = product ∘ map (max 1 ∘ read ∘ pure)

Explication

Je vais commencer par ce que j'avais initialement:

product.map(max 1.read.pure)

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 mappe max 1.read.puresur 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 la productde la liste résultante d'entiers ( 3).

Je l'ai ensuite joué au golf d'un octet avec:

foldr((*).max 1.read.pure)1

Cela fonctionne car productest équivalent à foldr (*) 1. Au lieu de mapper et de plier, j'ai combiné les deux en pliant avec (*).max 1.read.purelequel prend chaque chiffre non nul et le multiplie par l'accumulateur.

Python 2 , 34 octets

f=lambda n:n<1or(n%10or 1)*f(n/10)

Essayez-le en ligne!

Gelée , 4 octets

Do1P

Essayez-le en ligne! ou voir la suite de tests

Comment ça marche

Do1P - Main link. Argument: n (integer)  e.g. 1230456
D    - Digits                                 [1, 2, 3, 0, 4, 5, 6]
 o1  - Replace 0 with 1                       [1, 2, 3, 1, 4, 5, 6]
   P - Product                                720

R , 40 octets

cat(prod((x=scan()%/%10^(0:12)%%10)+!x))

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 par 1et calcule le produit.

cat(					#output
    prod(				#take the product of
         (x=				#set X to
	    scan()			#stdin
		  %/%10^(0:12)%%10)	#integer divide by powers of 10, mod 10, yields digits of the input, with leading zeros. So x is the digits of the input
                                   +!x  #add logical negation, elementwise. !x maps 0->1 and nonzero->0. adding this to x yields 0->1, leaving others unchanged
                                      ))

C (gcc) , 39 octets

k;f(n){for(k=1;n;n/=10)k*=n%10?:1;k=k;}

Doit être compilé sans optimisations (qui est de toute façon le paramètre par défaut pour gcc).

Essayez-le en ligne!

Brain-Flak , 74 72 70 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:

{ Loop over every number
  ([{}]((((()()()){}){}){}){}) Add 48 to the negative of the ASCII to get the negation of the digit
  { If the number is not 0
     ({<({}())><>([[]](){})<>}<><{}>)<> Multiply the total by the number
                                          If the total is on an empty stack, add 1
  } 
  {} Pop the excess 0
}<> Switch to the stack with the total

05AB1E , 4 octets

0KSP

Essayez-le en ligne!

Explication

0K     # remove zeroes
  S    # split to list of digits
   P   # product

J , _{17 14} 13 octets

-4 octets avec l'aimable autorisation de @GalenIvanov

[:*/1>.,.&.":

Essayez-le en ligne!

Peut probablement être amélioré certains. Edit: et il en fut ainsi.

Explication

[: */ 1 >. ,.&.":
                 ": Convert to string
             ,.     Convert row to column vector
               &.   Convert to numbers
      1 >.        Maximum of each element with 1 (convert 0 to 1)
   */              Product
[:                 Cap fork

&.-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).

Python 2 , 43 octets

lambda n:eval('*'.join(`n`.replace(*'01')))

Essayez-le en ligne!

JavaScript (ES6), 28 octets

Conçu pour les entiers 32 bits.

f=n=>!n||(n%10||1)*f(n/10|0)

Cas de test

f=n=>!n||(n%10||1)*f(n/10|0)

console.log(f(1))        // => 1
console.log(f(10))       // => 1
console.log(f(20))       // => 2
console.log(f(100))      // => 1
console.log(f(999))      // => 729
console.log(f(21333))    // => 54
console.log(f(17801))    // => 56
console.log(f(4969279))  // => 244944

Bash + coreutils + sed + bc, 27 24 23 octets

tr 0 1|sed s/\\B/*/g|bc

Essayez-le en ligne!

Brachylog , 5 octets

⊇ẹ×ℕ₁

Essayez-le en ligne!

Explication

⊇        Take a subset of the input
 ẹ       Split the subset into a list of digits
  ×      Product
   ℕ₁    This product must be in [1, +∞)

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.

Perl 5 , 23 + 1 ( -p) = 24 octets

$\=1;s/./$\*=$&||1/ge}{

Essayez-le en ligne!

Java 8, 55 54 53 51 octets

int f(int n){return n>0?(n%10>0?n%10:1)*f(n/10):1;}

Réponse de Python 2 du port de @Dennis .
-1 octet grâce à @RiaD .

Essayez-le ici.

55 Version 54 octets:

n->{int r=1;for(;n>0;n/=10)r*=n%10>0?n%10:1;return r;}

Essayez-le en ligne.

Julia 0,6, 26 octets

!x=prod(max.(digits(x),1))

Exemple d'utilisation:

julia> !54
20

Essayez-le en ligne!

JavaScript (Node.js) , 30 octets

f=([a,...b])=>a?(+a||1)*f(b):1

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||1renvoie le chiffre correspondant au acaractère. Je suppose que le repos s'explique de lui-même ..

Octave , 21 octets

Merci à @Luis Mendo d'avoir enregistré un octet et merci à @alephalpha d'avoir enregistré un autre octet!

@(n)prod((k=n-48)+~k)

Prend l'entrée sous la forme d'une chaîne de chiffres.

Essayez-le en ligne!

30 octets:

@(n)prod((k=num2str(n)-48)+~k)

Prend l'entrée sous forme de nombre.

Essayez-le en ligne!

Brain-Flak , 88 octets

Version lisible:

#Push a 1 onto the alternate stack. Return to the main stack
(<>())<>

#While True:
{

    #Push the current digit minus 48 (the ASCII value of '0') onto the alternate stack
    ({}[((((()()()){}){}){}){}]<>)

    #If it's not 0...
    {
        (<

            #Multiply the top two values (the current digit and the current product that started at 1)
            ({}<>)({<({}[()])><>({})<>}{}<><{}>)

        #Also push a 0
        >)

    #Endwhile
    }

    #Pop the 0
    {}

    #Return to the main stack
    <>

#Endwhile
}

#Toggle to the alternate stack, and implicitly display
<>

Essayez-le en ligne!

Clojure , 56 octets

(fn[n](apply *(replace{0 1}(map #(-(int %)48)(str n)))))

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!

(defn non-zero-prod [n]
  (let [; Abusing strings to get each digit individually
        str-n (str n)

        ; Then turn them back into numbers
        digits (map #(- (int %) 48) str-n)

        ; Substitute each 0 for a 1
        replaced (replace {0 1} digits)]

    ; Then get the product
    (apply * replaced)))

MATL , 5 octets

!UXzp

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

!     % Implicit input: string (row vector of chars). Transpose into
      % a column vector of chars
U     % Convert from string to number. Treats each row independently,
      % producing a column vector of numbers
Xz    % Keep only nonzeros
p     % Product. Implicit display

Befunge, 23 22 octets

1<*_$#`.#0@#:+!:-"0"~$

Essayez-le en ligne!

Explication

1<                        Push 1, turn back left, and push a second 1.       
                     $    Drop one of them, leaving a single 1, the initial product.

                -"0"~     Read a char and subtract ASCII '0', converting to a number.
             +!:          If it's 0, make it 1 (this is n + !n).
      `  0  :             Then test if it's greater than 0, to check for EOF.
   _                      If it is greater than 0, it wasn't EOF, so we continue left.
  *                       Multiply with the current product, becoming the new product.
1<                        Now we repeat the loop, but this time push only a single 1...
                     $    ...which is immediately dropped, leaving the current product.

   _                      On EOF, the input value will be negative, so we branch right.
    $                     We don't need the input, so drop it.
       .  @               Leaving us with the product, which we output, then exit.

JavaScript (Node.js) , 36 33 octets

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

s=>[...s].reduce((a,b)=>b*a||a,1)

Essayez-le en ligne!

Rubis, 42 40 35 32 27 octets

p eval (gets.chars-[?0])*?*

Ne suppose aucune nouvelle ligne dans l'entrée Influence majeure

-2 octets grâce à @GolfWolf

-5 octets grâce à @Conor O'Brien

Java (OpenJDK 8) , 45 octets

s->s.chars().reduce(1,(a,b)->b<49?a:a*(b-48))

Essayez-le en ligne!

C # , 97 octets (premier code de golf)

static int X(int y){var z=y.ToString();int r=1;foreach(var q in z){if(q!=48){r*=q-48;}}return r;}

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.

C # (Visual C # Interactive Compiler) , 46 octets

i.Select(c=>c>48?c-48:1).Aggregate((p,c)=>p*c)

Essayez-le en ligne!

Haskell , 36 octets

f n=product[read[d]|d<-show n,d>'0']

Même nombre d'octets:

f n=product[max 1$read[d]|d<-show n]

Essayez-le en ligne!

Gelée , 6 , 5 octets

ṢU×\Ṁ

Essayez-le en ligne!

> <> , 19 octets

1i:&0(?n&c4*-:0=+*!

Essayez-le en ligne!