^{Originalmente la raíz digital multiplicativa}

Reto

^{Básicamente haz lo que dice el título}

Método

Dado un entero positivo 1 <= N <= 100000000 a través de uno de nuestros métodos de entrada estándar , multiplique cada dígito, ignorando los ceros.

Ej .: toma un número y di 361218402:

• 3* 6=18
• 18* 1=18
• 18* 2=36
• 36* 1=36
• 36* 8=288
• 288* 4=1152
• 1152* 1 ^{(ignore los ceros o conviértalos en unos)} =1152
• 1152* 2=2304

La salida para 361218402es2304

Casos de prueba

1 => 1
cada dos dígitos> 0 => sí mismo
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

Las lagunas estándar no están permitidas, y este es el código de golf , por lo que gana el conteo de bytes más corto.

¡Enhorabuena a Jo King que obtuvo la recompensa con su respuesta de 70 bytes!

Pyt , 3 bytes

ąžΠ

Explicación:

ą       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

Pruébalo en línea!

Haskell , 27 bytes

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

Pruébalo en línea!

Ungolfed con UniHaskell y-XUnicodeSyntax

import UniHaskell

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

Explicación

Comenzaré con lo que tenía inicialmente:

product.map(max 1.read.pure)

Esta es una expresión sin puntos que se evalúa como una función que toma una cadena (o una lista de caracteres) s ( "301") como argumento. Se asigna max 1.read.puresobre s , esencialmente tomando cada carácter i , inyectándolo en una lista (lo que lo convierte en una cadena) ( ["3", "0", "1"]), luego lo lee, lo que evalúa la cadena ( [3, 0, 1]) y finalmente toma el mayor de i y 1 ( [3, 1, 1]). Luego toma la productlista resultante de enteros ( 3).

Luego lo jugué por un byte con:

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

Esto funciona porque productes equivalente a foldr (*) 1. En lugar de mapear y doblar, combiné los dos doblando con lo (*).max 1.read.pureque toma cada dígito distinto de cero y lo multiplica con el acumulador.

Python 2 , 34 bytes

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

Pruébalo en línea!

Jalea , 4 bytes

Do1P

Pruébalo en línea! o ver el conjunto de pruebas

Cómo funciona

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 bytes

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

Pruébalo en línea!

Como se garantiza que la entrada no tiene más de 12 dígitos, esto debería funcionar bien. Calcula los dígitos como x(incluidos los ceros iniciales), luego reemplaza los ceros con 1y calcula el producto.

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 bytes

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

Necesita compilarse sin optimizaciones (que es la configuración predeterminada para gcc, de todos modos).

Pruébalo en línea!

Brain-Flak , 74 72 70 bytes

-2 gracias a Nitrodon por sugerir obtener la negación del número para que solo tenga que aumentar en lugar de disminuir más adelante

{([{}]((((()()()){}){}){}){}){({<({}())><>([[]](){})<>}<><{}>)<>}{}}<>

Pruébalo en línea!

Puede haber algunas formas de jugar más al golf, como rehacer la multiplicación para evitar tener que inicializar el total con 1. (-2 bytes)

Cómo funciona:

{ 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 bytes

0KSP

Pruébalo en línea!

Explicación

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

J , _{17 14} 13 bytes

-4 bytes cortesía de @GalenIvanov

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

Pruébalo en línea!

Probablemente se pueda mejorar algo. Editar: y así fue.

Explicación

[: */ 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 es un ingenioso adverbio que aplica el verbo a la derecha, luego el verbo a la izquierda, luego el inverso del verbo a la derecha. También convertir de nuevo a números es técnicamente usando eval ( ".-do).

Python 2 , 43 bytes

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

Pruébalo en línea!

JavaScript (ES6), 28 bytes

Diseñado para enteros de 32 bits.

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

Casos de prueba

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 bytes

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

Pruébalo en línea!

Brachylog , 5 bytes

⊇ẹ×ℕ₁

Pruébalo en línea!

Explicación

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

Esto funciona porque ⊇unifica desde subconjuntos grandes a subconjuntos pequeños, por lo que el primero que dará como resultado un producto distinto de cero es cuando se excluyen todos los ceros y nada más.

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

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

Pruébalo en línea!

Java 8, 55 54 53 51 bytes

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

Puerto de @Dennis 'Python 2 respuesta .
-1 byte gracias a @RiaD .

Pruébalo aquí

55 Versión de 54 bytes:

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

Pruébalo en línea.

Julia 0.6, 26 bytes

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

Ejemplo de uso:

julia> !54
20

Pruébalo en línea!

JavaScript (Node.js) , 30 bytes

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

Pruébalo en línea!

Toma una cadena como entrada, la trata como una matriz y, mediante la desestructuración de la matriz, se separa el primer elemento [a,...b]. +a||1Devuelve el dígito correspondiente al acarácter. Supongo que el descanso se explica por sí mismo.

Octava , 21 bytes

¡Gracias a @Luis Mendo por guardar un byte y gracias a @alephalpha por guardar otro byte!

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

Toma la entrada como una cadena de dígitos.

Pruébalo en línea!

30 bytes:

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

Toma la entrada como un número.

Pruébalo en línea!

Brain-Flak , 88 bytes

Versión legible:

#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
<>

Pruébalo en línea!

Clojure , 56 bytes

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

Bastante básico Convierte el número en una cadena, luego resta 48 de cada carácter para volverlos a convertir en números. Luego reemplaza cada 0 con un 1, y aplica* a la lista de números resultante (que se reduce *sobre la lista). Puede aceptar un número o un número en cadena.

Pruébalo en línea!

(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 bytes

!UXzp

La entrada se toma como una cadena

¡Pruébalo en MATL Online! O verifique los casos de prueba en ¡Pruébelo en línea!

Explicación

!     % 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 bytes

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

Pruébalo en línea!

Explicación

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 bytes

Método Javascript simple (ES6) que toma la entrada como una cadena de números, la distribuye en una matriz y luego la reduce a través de la multiplicación o devuelve el valor si el resultado es 0.

3 bytes guardados gracias a Shaggy

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

Pruébalo en línea!

Ruby, 42 40 35 32 27 bytes

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

Asume que no hay líneas nuevas en la entrada Mayor influencia

-2 bytes gracias a @GolfWolf

-5 bytes gracias a @Conor O'Brien

Java (OpenJDK 8) , 45 bytes

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

Pruébalo en línea!

C # , 97 Bytes (primer código 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;}

No estoy seguro si tuve que envolverlo en un método o no, así que solo lo incluí para que sea seguro.

Toma un Int, lo convierte en una cadena y devuelve el múltiplo de cada uno de los caracteres ignorando los 0. Tuvo que menos 48 debido a que el programa usa el valor ascii ya que lo lee como un char.

C # (compilador interactivo de Visual C #) , 46 bytes

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

Pruébalo en línea!

Haskell , 36 bytes

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

Mismo recuento de bytes:

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

Pruébalo en línea!

Gelatina , 6 , 5 bytes

ṢU×\Ṁ

Pruébalo en línea!

> <> , 19 bytes

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

Pruébalo en línea!