^{Спочатку мультиплікативний цифровий корінь}

Виклик

^{В основному роби те, що говорить заголовок}

Метод

Давши додатне ціле число 1 <= N <= 100000000 за допомогою одного з наших стандартних методів введення , множте кожну цифру разом, ігноруючи нулі.

Наприклад: Візьміть число, скажіть 361218402:

• 3* 6=18
• 18* 1=18
• 18* 2=36
• 36* 1=36
• 36* 8=288
• 288* 4=1152
• 1152* 1 ^{(ігноруйте нулі або перетворіть їх на одиниці)} =1152
• 1152* 2=2304

Вихід для 361218402IS2304

Випробування

1 => 1
кожна інша цифра> 0 => себе
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

Стандартні лазівки заборонені, і це код-гольф , тому виграйте найменший байт!

Вітаю Джо Кінга, який отримав щедроту зі своєю відповіді на 70-байтний мозок!

Pyt , 3 байти

ąžΠ

Пояснення:

ą       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

Спробуйте в Інтернеті!

Haskell , 27 байт

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

Спробуйте в Інтернеті!

Unololfed з UniHaskell і-XUnicodeSyntax

import UniHaskell

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

Пояснення

Почну з того, що у мене було:

product.map(max 1.read.pure)

Це вираження без точок, яке оцінює функцію, яка бере аргумент (або список символів) s ( "301"). Він відображає max 1.read.pureнад S , по суті , приймаючи кожен знак I , вводячи його в список (що робить його рядок) ( ["3", "0", "1"]), а потім читати його, який обчислює рядок ( [3, 0, 1]) і , нарешті , приймати більше з I і 1 ( [3, 1, 1]). Тоді він приймає productрезультуючий список цілих чисел ( 3).

Потім я переграв його на байті з:

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

Це працює, тому що productеквівалентно foldr (*) 1. Замість картографування та складання я поєднав два, склавши за допомогою (*).max 1.read.pureякого беручи кожну ненульову цифру і помноживши її на акумулятор.

Python 2 , 34 байти

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

Спробуйте в Інтернеті!

Желе , 4 байти

Do1P

Спробуйте в Інтернеті! або побачити тестовий набір

Як це працює

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 байт

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

Спробуйте в Інтернеті!

Оскільки вхід гарантовано містить не більше 12 цифр, це має працювати добре. Обчислює цифри як x(включаючи провідні нулі), а потім замінює нулі на 1та обчислює добуток.

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 байт

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

Необхідно компілювати без оптимізацій (це все одно за замовчуванням для gcc).

Спробуйте в Інтернеті!

Мозг-Флак , 74 72 70 байт

-2 завдяки Nitrodon за те, що він запропонував отримати заперечення числа, так що вам доведеться лише збільшувати, а не зменшувати пізніше

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

Спробуйте в Інтернеті!

Можливо, існує кілька способів продовжити гольф, наприклад, повторення множення, щоб уникнути необхідності ініціалізації загальної величини з 1. (-2 байти)

Як це працює:

{ 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 байти

0KSP

Спробуйте в Інтернеті!

Пояснення

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

J , _{17 14} 13 байт

-4 байти люб’язно надано @GalenIvanov

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

Спробуйте в Інтернеті!

Напевно, можна дещо вдосконалити. Редагувати: і так було.

Пояснення

[: */ 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 - витончений прислівник, який застосовує дієслово праворуч, потім дієслово зліва, потім зворотне дієслово праворуч. Також для технічного перетворення на номери технічно використовується eval ( ".-do).

Python 2 , 43 байти

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

Спробуйте в Інтернеті!

JavaScript (ES6), 28 байт

Призначений для 32-бітних цілих чисел.

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

Тестові справи

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 байт

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

Спробуйте в Інтернеті!

Брахілог , 5 байт

⊇ẹ×ℕ₁

Спробуйте в Інтернеті!

Пояснення

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

Це працює, тому що ⊇об’єднує великі підмножини в малі підмножини, тому перше, що призведе до ненульового продукту, - це коли всі нулі виключені і більше нічого.

Perl 5 , 23 + 1 ( -p) = 24 байти

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

Спробуйте в Інтернеті!

Java 8, 55 54 53 51 байт

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

Порт @Dennis 'Python 2 відповідь .
-1 байт завдяки @RiaD .

Спробуйте тут.

Версія 55 54 байти:

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

Спробуйте в Інтернеті.

Джулія 0,6, 26 байт

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

Приклад використання:

julia> !54
20

Спробуйте в Інтернеті!

JavaScript (Node.js) , 30 байт

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

Спробуйте в Інтернеті!

Приймає рядок як вхідний, трактує його як масив, а шляхом деструктуризації масиву відокремлює перший елемент [a,...b]. +a||1повертає цифру, відповідну aсимволу. Я думаю, що відпочинок сам пояснює ..

Октава , 21 байт

Дякуємо @Luis Mendo за збереження байту та спасибі @alephalpha за збереження ще одного байта!

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

Вводить введення як рядок цифр.

Спробуйте в Інтернеті!

30 байт:

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

Вводиться як число.

Спробуйте в Інтернеті!

Мозок-Флак , 88 байт

Читаема версія:

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

Спробуйте в Інтернеті!

Clojure , 56 байт

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

Досить базовий. Перетворює число в рядок, потім віднімає 48 з кожного символу, щоб перетворити їх назад у числа. Потім він замінює кожен 0 на 1 і застосовується *до отриманого списку чисел (який зменшується *над списком). Можна прийняти номер або рядковий номер.

Спробуйте в Інтернеті!

(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 байт

!UXzp

Введення приймається як рядок

Спробуйте в MATL Online! Або перевірити тестові випадки в "Try it Online"!

Пояснення

!     % 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 байти

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

Спробуйте в Інтернеті!

Пояснення

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 байт

Простий метод Javascript (ES6), який приймає введення як числовий рядок, поширює його в масив, потім зменшує його шляхом множення або повертає значення, якщо результат дорівнює 0.

3 байти збережено завдяки Шаггі

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

Спробуйте в Інтернеті!

Рубі, 42 40 35 32 27 байт

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

Не передбачає нових рядків у введенні Основний вплив

-2 байти завдяки @GolfWolf

-5 байт завдяки @Conor O'Brien

Java (OpenJDK 8) , 45 байт

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

Спробуйте в Інтернеті!

C # , 97 байт (гольф першого коду)

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

Не впевнений, чи довелося мені обернути його методом чи не так просто включив його в безпеку.

Займає Int in, перетворює його в рядок і повертає кратне число кожного символу, ігноруючи 0. Прийшлося до мінус 48 через програму, яка використовує значення ascii, оскільки вона читає її як знак.

C # (Visual C # Interactive Compiler) , 46 байт

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

Спробуйте в Інтернеті!

Haskell , 36 байт

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

Кількість байтів:

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

Спробуйте в Інтернеті!

Желе , 6 , 5 байт

ṢU×\Ṁ

Спробуйте в Інтернеті!

> <> , 19 байт

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

Спробуйте в Інтернеті!