^{Ban đầu là gốc số nhân}

Thử thách

^{Về cơ bản làm những gì tiêu đề nói}

phương pháp

Cho số nguyên dương 1 <= N <= 100000000 thông qua một trong các phương thức nhập tiêu chuẩn của chúng tôi , nhân mọi chữ số với nhau, bỏ qua các số không.

Vd Lấy một số, nói 361218402:

• 3* 6=18
• 18 * 1=18
• 18 * 2=36
• 36 * 1=36
• 36 * 8=288
• 288 * 4=1152
• 1152 * 1 ^{(bỏ qua các số 0 hoặc biến chúng thành các số)} =1152
• 1152 * 2=2304

Đầu ra cho 361218402 là2304

Các trường hợp thử nghiệm

1 => 1
mỗi chữ số khác> 0 => chính nó
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

Các lỗ hổng tiêu chuẩn không được phép và đây là môn đánh gôn , vì vậy số byte ngắn nhất sẽ thắng!

Xin chúc mừng Jo King , người đã nhận được tiền thưởng với câu trả lời cân não 70 byte của mình!

Pyt , 3 byte

ąžΠ

Giải trình:

ą       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

Hãy thử trực tuyến!

Haskell , 27 byte

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

Hãy thử trực tuyến!

Ung dung với UniHaskell và-XUnicodeSyntax

import UniHaskell

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

Giải trình

Tôi sẽ bắt đầu với những gì ban đầu tôi có:

product.map(max 1.read.pure)

Đây là một điểm miễn biểu hiện mà đánh giá lại để một chức năng tham gia một chuỗi (hoặc một danh sách các nhân vật) s ( "301") như một cuộc tranh cãi. Nó ánh xạ max 1.read.purequa s , về cơ bản lấy từng ký tự i , đưa nó vào một danh sách (làm cho nó thành một chuỗi) ( ["3", "0", "1"]), sau đó đọc nó, để đánh giá chuỗi ( [3, 0, 1]) và cuối cùng lấy số lớn hơn của i và 1 ( [3, 1, 1]). Sau đó, nó lấy productdanh sách kết quả của số nguyên ( 3).

Sau đó tôi đánh gôn nó bằng một byte với:

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

Điều này hoạt động vì producttương đương với foldr (*) 1. Thay vì ánh xạ và gấp, tôi kết hợp cả hai bằng cách gấp với (*).max 1.read.puremỗi chữ số khác không và nhân nó với bộ tích lũy.

Python 2 , 34 byte

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

Hãy thử trực tuyến!

Thạch , 4 byte

Do1P

Hãy thử trực tuyến! hoặc xem kiểm tra

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến!

Vì đầu vào được đảm bảo không có quá 12 chữ số, nên điều này sẽ hoạt động tốt. Tính các chữ số dưới dạng x(bao gồm các số 0 đứng đầu), sau đó thay thế các số không bằng 1và tính toán sản phẩm.

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 byte

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

Cần phải được biên dịch mà không cần tối ưu hóa (dù sao đó cũng là cài đặt mặc định cho gcc).

Hãy thử trực tuyến!

Brain-Flak , 74 72 70 byte

-2 cảm ơn Nitrodon vì đã gợi ý cách phủ định số để bạn chỉ phải tăng lên chứ không phải giảm sau

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

Hãy thử trực tuyến!

Có thể có một vài cách để chơi gôn hơn nữa, chẳng hạn như làm lại phép nhân để tránh phải khởi tạo tổng số bằng 1. (-2 byte)

Làm thế nào nó hoạt động:

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

0KSP

Hãy thử trực tuyến!

Giải trình

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

J , _{17 14} 13 byte

-4 byte lịch sự của @GalenIvanov

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

Hãy thử trực tuyến!

Có lẽ có thể được cải thiện một số. Chỉnh sửa: và nó đã được như vậy.

Giải trình

[: */ 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 là một trạng từ tiện lợi áp dụng động từ bên phải, sau đó là động từ bên trái, sau đó là động từ nghịch đảo của động từ bên phải. Ngoài ra, chuyển đổi trở lại số là về mặt kỹ thuật bằng cách sử dụng eval ( ".-do).

Python 2 , 43 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 28 byte

Được thiết kế cho số nguyên 32 bit.

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

Các trường hợp thử nghiệm

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 byte

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

Hãy thử trực tuyến!

Brachylog , 5 byte

⊇ẹ×ℕ₁

Hãy thử trực tuyến!

Giải trình

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

Điều này hoạt động vì ⊇thống nhất từ ​​các tập con lớn đến các tập con nhỏ, do đó, tập hợp đầu tiên sẽ dẫn đến một sản phẩm khác không là khi tất cả các số 0 được loại trừ và không có gì khác.

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

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

Hãy thử trực tuyến!

Java 8, 55 54 53 51 byte

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

Cổng của câu trả lời Python 2 của @Dennis .
-1 byte nhờ @RiaD .

Hãy thử nó ở đây.

Phiên bản 55 54 byte:

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

Hãy thử trực tuyến.

Julia 0,6, 26 byte

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

Ví dụ sử dụng:

julia> !54
20

Hãy thử trực tuyến!

JavaScript (Node.js) , 30 byte

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

Hãy thử trực tuyến!

Lấy chuỗi làm đầu vào, coi nó là mảng và bằng cách phá hủy mảng sẽ tách phần tử đầu tiên [a,...b]. +a||1trả về chữ số tương ứng với aký tự. Tôi đoán rằng phần còn lại là tự giải thích ..

Octave , 21 byte

Cảm ơn @Luis Mendo vì đã lưu một byte và cảm ơn @alephalpha vì đã lưu một byte khác!

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

Đưa đầu vào dưới dạng một chuỗi các chữ số.

Hãy thử trực tuyến!

30 byte:

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

Lấy đầu vào là một số.

Hãy thử trực tuyến!

Brain-Flak , 88 byte

Phiên bản dễ đọc:

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

Hãy thử trực tuyến!

Clojure , 56 byte

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

Khá cơ bản. Biến số thành một chuỗi, sau đó trừ 48 từ mỗi ký tự để biến chúng trở lại thành số. Sau đó, nó thay thế mỗi 0 bằng 1 và áp dụng *cho danh sách số kết quả (làm giảm *danh sách). Có thể chấp nhận một số, hoặc một số chuỗi.

Hãy thử trực tuyến!

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

!UXzp

Đầu vào được lấy dưới dạng chuỗi

Hãy thử nó tại MATL Online! Hoặc xác minh các trường hợp thử nghiệm trong Dùng thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Giải trình

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 byte

Phương pháp Javascript đơn giản (ES6) lấy đầu vào dưới dạng chuỗi số, trải rộng nó thành một mảng, sau đó giảm nó thông qua phép nhân hoặc trả về giá trị nếu kết quả là 0.

3 byte được lưu nhờ Shaggy

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

Hãy thử trực tuyến!

Ruby, 42 40 35 32 27 byte

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

Giả sử không có dòng mới trong đầu vào Ảnh hưởng lớn

-2 byte nhờ @GolfWolf

-5 byte nhờ @Conor O'Brien

Java (OpenJDK 8) , 45 byte

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

Hãy thử trực tuyến!

C # , 97 Byte (Golf mã đầu tiên)

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

Không chắc chắn nếu tôi phải bọc nó trong một phương pháp hay không nên chỉ bao gồm nó để được an toàn.

Đưa một Int vào, chuyển đổi nó thành một chuỗi và trả về bội số của mỗi ký tự bỏ qua 0. Phải trừ 48 do chương trình sử dụng giá trị ascii khi nó đọc nó dưới dạng char.

C # (Trình biên dịch tương tác Visual C #) , 46 byte

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

Hãy thử trực tuyến!

Haskell , 36 byte

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

Cùng một số byte:

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

Hãy thử trực tuyến!

Thạch , 6 , 5 byte

ṢU×\Ṁ

Hãy thử trực tuyến!

> <> , 19 byte

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

Hãy thử trực tuyến!