^{Ursprünglich die multiplikative digitale Wurzel}

Herausforderung

^{Grundsätzlich tun, was der Titel sagt}

Methode

Bei einer positiven Ganzzahl von 1 <= N <= 100000000 mit einer unserer Standardeingabemethoden multiplizieren Sie jede Ziffer miteinander und ignorieren Sie dabei Nullen.

Bsp .: Nehmen Sie eine Zahl, sagen Sie 361218402:

• 3* 6=18
• 18* 1=18
• 18* 2=36
• 36* 1=36
• 36* 8=288
• 288* 4=1152
• 1152* 1 ^{(Nullen ignorieren oder in Einsen verwandeln)} =1152
• 1152* 2=2304

Die Ausgabe für 361218402ist2304

Testfälle

1 => 1
jede zweite Ziffer> 0 => sich selbst
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

Standard-Schlupflöcher sind nicht zulässig, und dies ist Codegolf , so dass die kürzeste Anzahl an Bytes gewinnt!

Herzlichen Glückwunsch an Jo King , der mit seiner 70-Byte-Brain-Flak-Antwort das Kopfgeld erhalten hat !

Pyt , 3 Bytes

ąžΠ

Erläuterung:

ą       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

Probieren Sie es online!

Haskell , 27 Bytes

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

Probieren Sie es online!

Ungolfed mit UniHaskell und-XUnicodeSyntax

import UniHaskell

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

Erläuterung

Ich beginne mit dem, was ich anfangs hatte:

product.map(max 1.read.pure)

Hierbei handelt es sich um einen punktfreien Ausdruck, der zu einer Funktion ausgewertet wird, die einen String (oder eine Liste von Zeichen) s ( "301") als Argument verwendet. Es bildet max 1.read.pureüber s , im Wesentlichen jedes Zeichen unter i , es in eine Liste Injektion ((was ein String macht) ["3", "0", "1"]), dann ist es zu lesen, die die Zeichenfolge auswertet ( [3, 0, 1]) und schließlich die größere der Einnahme i und 1 ([3, 1, 1] ). Dann nimmt es die productaus der resultierenden Liste der ganzen Zahlen ( 3).

Ich habe es dann byteweise golfen mit:

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

Das funktioniert, weil productes äquivalent zu ist foldr (*) 1. Anstatt zu mappen und zu falten, habe ich die beiden durch Falten kombiniert, wobei (*).max 1.read.purejede Ziffer ungleich Null genommen und mit dem Akkumulator multipliziert wird.

Python 2 , 34 Bytes

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

Probieren Sie es online!

Gelee , 4 Bytes

Do1P

Probieren Sie es online! oder sehen Sie sich die Testsuite an

Wie es funktioniert

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

Probieren Sie es online!

Da die Eingabe garantiert nicht mehr als 12 Stellen hat, sollte dies gut funktionieren. Berechnet die Ziffern als x(einschließlich führender Nullen), ersetzt dann die Nullen durch 1und berechnet das Produkt.

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

Muss ohne Optimierungen kompiliert werden (was ohnehin die Standardeinstellung für gcc ist).

Probieren Sie es online!

Brain-Flak , 74, 72 70 Bytes

-2 Dank an Nitrodon für den Vorschlag, die Negation der Zahl zu erhalten, damit Sie später nur noch inkrementieren und nicht dekrementieren müssen

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

Probieren Sie es online!

Es gibt möglicherweise einige Möglichkeiten, dies weiter zu verbessern , z. B. das Wiederherstellen der Multiplikation, um zu vermeiden, dass die Summe mit 1 initialisiert werden muss. (-2 Bytes)

Wie es funktioniert:

{ 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

Probieren Sie es online!

Erläuterung

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

J , _{17 14} 13 Bytes

-4 Bytes mit freundlicher Genehmigung von @GalenIvanov

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

Probieren Sie es online!

Wahrscheinlich kann man einiges verbessern. Edit: und so war es.

Erläuterung

[: */ 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 ist ein geschicktes Adverb, das das Verb auf der rechten Seite, dann das Verb auf der linken Seite und dann die Umkehrung des Verbs auf der rechten Seite anwendet . Auch das Zurückkonvertieren in Zahlen erfolgt technisch mit eval ( ".-do).

Python 2 , 43 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 28 Byte

Entwickelt für 32-Bit-Ganzzahlen.

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

Testfälle

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

Probieren Sie es online!

Brachylog , 5 Bytes

⊇ẹ×ℕ₁

Probieren Sie es online!

Erläuterung

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

Dies funktioniert, weil ⊇von großen Teilmengen zu kleinen Teilmengen vereinheitlicht wird. Das erste, was zu einem Produkt ungleich Null führt, ist, wenn alle Nullen ausgeschlossen sind und sonst nichts.

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

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

Probieren Sie es online!

Java 8, 55 54 53 51 Bytes

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

Port von @Dennis 'Python 2 Antwort .
-1 Byte dank @RiaD .

Probieren Sie es hier aus.

55 54 Bytes Version:

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

Probieren Sie es online aus.

Julia 0,6, 26 Bytes

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

Anwendungsbeispiel:

julia> !54
20

Probieren Sie es online!

JavaScript (Node.js) , 30 Byte

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

Probieren Sie es online!

Nimmt einen String als Eingabe, behandelt ihn als Array und trennt durch Array-Destrukturierung das erste Element [a,...b]. +a||1Gibt die dem aZeichen entsprechende Ziffer zurück . Ich denke, dass der Rest selbsterklärend ist ..

Oktave , 21 Bytes

Danke an @Luis Mendo für das Speichern eines Bytes und danke an @alephalpha für das Speichern eines weiteren Bytes!

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

Übernimmt die Eingabe als Ziffernfolge.

Probieren Sie es online!

30 Bytes:

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

Nimmt die Eingabe als Zahl an.

Probieren Sie es online!

Gehirn-Flak , 88 Bytes

Lesbare Version:

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

Probieren Sie es online!

Clojure , 56 Bytes

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

Ziemlich einfach. Wandelt die Zahl in eine Zeichenfolge um und subtrahiert dann 48 von jedem Zeichen, um sie wieder in Zahlen umzuwandeln. Es ersetzt dann jede 0 durch eine 1 und gilt *für die sich ergebende Liste von Zahlen (die sich verringert)* über der Liste ). Kann eine Zahl oder eine fortlaufende Zahl akzeptieren.

Probieren Sie es online!

(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

Die Eingabe wird als Zeichenfolge verwendet

Probieren Sie es bei MATL Online! Oder verifizieren Sie Testfälle in Try It Online!

Erläuterung

!     % 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"~$

Probieren Sie es online!

Erläuterung

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

Einfache Javascript (ES6) -Methode, die Eingaben als Zahlenzeichenfolge verwendet, sie in ein Array aufteilt und dann durch Multiplikation reduziert oder den Wert zurückgibt, wenn das Ergebnis 0 ist.

3 Bytes gespart dank Shaggy

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

Probieren Sie es online!

Ruby, 42 40 35 32 27 Bytes

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

Setzt keine Zeilenumbrüche in der Eingabe voraus Einfluss

-2 Bytes dank @GolfWolf

-5 Bytes dank @Conor O'Brien

Java (OpenJDK 8) , 45 Byte

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

Probieren Sie es online!

C # , 97 Bytes (erster Code 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;}

Ich bin mir nicht sicher, ob ich es in eine Methode einwickeln musste oder nicht, nur um sicher zu gehen.

Nimmt ein Int auf, konvertiert es in einen String und gibt das Vielfache jedes Zeichens zurück, wobei die Nullen ignoriert werden. Musste minus 48, weil das Programm den ASCII-Wert als Zeichen liest.

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

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

Probieren Sie es online!

Haskell , 36 Bytes

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

Gleiche Byteanzahl:

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

Probieren Sie es online!

Jelly , 6 , 5 Bytes

ṢU×\Ṁ

Probieren Sie es online!

> <> , 19 Bytes

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

Probieren Sie es online!