^{원래 곱셈 디지털 루트}

도전

^{기본적으로 제목이 말하는 것을 수행}

방법

표준 입력 방법 중 하나를 통해 양의 정수 1 <= N <= 100000000이 주어지면 0을 무시하고 모든 숫자를 곱하십시오.

예 : 다음 과 같이 말합니다 361218402.

• 3* 6=18
• 18* 1=18
• 18* 2=36
• 36* 1=36
• 36* 8=288
• 288* 4=1152
• 1152* 1 ^{(0을 무시하거나 1로 바꿈)} =1152
• 1152* 2=2304

에 대한 출력 361218402은2304

테스트 사례

1 => 1
다른 모든 자릿수> 0 => 자체
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

표준 허점 은 허용되지 않으며 이것은 code-golf 이므로 가장 짧은 바이트 수가 이깁니다!

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

온라인으로 사용해보십시오!

하스켈 , 27 바이트

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

온라인으로 사용해보십시오!

와 Ungolfed UniHaskell 및-XUnicodeSyntax

import UniHaskell

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

설명

나는 처음에 가지고 있었던 것부터 시작할 것이다 :

product.map(max 1.read.pure)

이는 문자열 (또는 문자 목록) s ( )를 인수 로 사용하는 함수로 평가 되는 포인트없는 표현식입니다 . 이것은 매핑 위에 들 본질적 각 문자를 가지고, I를 ,리스트로 주입 (IT (문자열 수 있음) ), 다음을 읽고, 문자열 (평가 된 ) 마지막으로 더 큰 복용 전 및 1 ( ). 그런 다음 결과 정수 목록 ( )을 가져옵니다 ."301"max 1.read.pure["3", "0", "1"][3, 0, 1][3, 1, 1]product3

그런 다음 바이트 단위로 골프를 쳤습니다.

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

이것은 product에 해당하기 때문에 작동 합니다 foldr (*) 1. 매핑과 접기 대신, (*).max 1.read.pure0이 아닌 각 숫자를 가져와 누산기와 곱하여 두 개를 결합 했습니다.

파이썬 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오는 0을 포함 하여 계산 한 다음 0을 곱하고 제품을 계산합니다.

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의 기본 설정 임).

온라인으로 사용해보십시오!

Brain-Flak , 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 바이트

@GalenIvanov 제공 -4 바이트

[:*/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)을 사용하여 숫자로 다시 변환 합니다.

파이썬 2 , 43 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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

배쉬 + coreutils + sed + bc, 27 24 23 바이트

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

온라인으로 사용해보십시오!

Brachylog , 5 바이트

⊇ẹ×ℕ₁

온라인으로 사용해보십시오!

설명

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

이는 ⊇큰 하위 집합에서 작은 하위 집합으로 통합되므로 0이 아닌 제품을 만드는 첫 번째 항목은 모든 0이 제외되고 다른 항목이없는 경우입니다.

Perl 5 , 23 + 1 ( -p) = 24 바이트

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

온라인으로 사용해보십시오!

자바 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 답변 . @RiaD
덕분에 -1 바이트 .

여기에서 시도하십시오.

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

온라인으로 사용해보십시오!

자바 스크립트 (Node.js) , 30 바이트

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

온라인으로 사용해보십시오!

취하고 문자열 , 입력으로서 배열로 취급하여, 그리고 어레이 destructuring 첫번째 요소를 분리한다 [a,...b]. 문자에 +a||1해당하는 숫자를 반환 a합니다. 나는 휴식이 자기 설명이라고 생각한다 ..

옥타브 , 21 바이트

바이트를 저장 한 @Luis Mendo와 다른 바이트를 저장 한 @alephalpha에게 감사드립니다!

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

입력을 문자열로 취합니다.

온라인으로 사용해보십시오!

30 바이트 :

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

입력을 숫자로 취합니다.

온라인으로 사용해보십시오!

Brain-Flak , 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
<>

온라인으로 사용해보십시오!

클로저 , 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 에서 사용해보십시오 ! 또는 온라인 사용해보기에서 테스트 사례를 확인하십시오!

설명

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

자바 스크립트 (Node.js) , 36 33 바이트

입력을 숫자 문자열로 가져 와서 배열로 펼친 다음 곱셈을 통해 줄이거 나 결과가 0이면 값을 리턴하는 단순 Javascript (ES6) 메소드입니다.

Shaggy 덕분에 3 바이트 절약

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

온라인으로 사용해보십시오!

루비, 42 40 35 32 27 바이트

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

입력에 줄 바꿈이 없다고 가정합니다.

@GolfWolf 덕분에 -2 바이트

@Conor O'Brien 덕분에 -5 바이트

자바 (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를 가져 와서 문자열로 변환하고 0을 무시하는 각 문자의 배수를 반환합니다. 프로그램이 문자로 읽을 때 ascii 값을 사용하여 마이너스 48을 냈습니다.

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

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

Try it online!

Haskell, 36 bytes

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

Same byte count:

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

Try it online!

Jelly, 6, 5 bytes

ṢU×\Ṁ

Try it online!

><>, 19 bytes

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

Try it online!