^{Başlangıçta Çarpımsal dijital kök}

Meydan okuma

^{Temel olarak başlık ne diyorsa yapın}

Yöntem

Olumlu bir tamsayı verilen 1 <= N <= 100000000 , standart giriş yöntemlerimizden biriyle, her basamağı çarparak sıfırları yok sayarak.

Ör: Bir numarayı alın demek 361218402:

• 3* 6=18
• 18* 1=18
• 18* 2=36
• 36* 1=36
• 36* 8=288
• 288* 4=1152
• 1152* 1 ^{(sıfırları görmezden gel veya onları bunlara çevir)} =1152
• 1152* 2=2304

İçin çıkış 361218402DİR2304

Test Kılıfları

1 => 1
diğer her basamak> 0 => kendisi
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

Standart Loopholes'a izin verilmiyor ve bu kod golf , yani en kısa bayt sayısı kazanıyor!

Tebrikler Jo Kral ile ödül aldık onun 70 bayt beyin kurşun geçirmez cevap!

Pyt , 3 bayt

ąžΠ

Açıklama:

ą       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

Çevrimiçi deneyin!

Haskell , 27 bayt

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

Çevrimiçi deneyin!

UniHaskell ile Ungolfed ve-XUnicodeSyntax

import UniHaskell

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

açıklama

Başlangıçta sahip olduklarım ile başlayacağım:

product.map(max 1.read.pure)

Bu bir nokta içermeyen bir işleve değerlendirir bir dizi (ya da karakterler listesi) alarak bu ifade s ( "301"bir bağımsız değişken olarak). Esasen her bir karakteri i alan , onu bir listeye enjekte eden (bir dize yapan) ( ), sonra onu okuyan, dizeyi ( ) değerlendiren ve son olarak da i ve 1 ( ) ' in büyük harflerini alarak smax 1.read.pure üzerinde eşler . Sonra ortaya çıkan tamsayıların listesini alır ( ).["3", "0", "1"][3, 0, 1][3, 1, 1]product3

Daha sonra bir bayt tarafından golf oynadım:

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

Bu çalışır çünkü producteşdeğerdir foldr (*) 1. Haritalama ve katlama yerine, (*).max 1.read.pureher ikisini de sıfır olmayan basamağı alıp akümülatör ile çarparak katlayarak birleştirdim .

Python 2,34 bayt

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

Çevrimiçi deneyin!

Jöle , 4 bayt

Do1P

Çevrimiçi deneyin! veya test odasına bakın

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin!

Girişin en fazla 12 rakamdan oluşması garanti edildiğinden, bunun iyi çalışması gerekir. Rakamları x(baştaki sıfırlar dahil) olarak hesaplar , sonra sıfırları 1ürünle değiştirir ve hesaplar.

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 bayt

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

Optimizasyonlar olmadan derlenmesi gerekiyor (ki yine de gcc için varsayılan ayardır).

Çevrimiçi deneyin!

Brain-Flak , 74 72 70 bayt

-2 Nitrodon'a, sayının olumsuzlamasını aldığınızı önerdiği için teşekkür ederiz.

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

Çevrimiçi deneyin!

Toplamı 1 ile başlatmak zorunda kalmaktan kaçınmak için çarpmayı tekrarlamak gibi, bunu daha fazla golf kullanmanın birkaç yolu olabilir (-2 bayt)

Nasıl çalışır:

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

0KSP

Çevrimiçi deneyin!

açıklama

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

J , _{17 14} 13 bayt

-4 bytes @GalenIvanov'un izniyle

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

Çevrimiçi deneyin!

Muhtemelen bazı geliştirilebilir. Düzenleme: ve böylece oldu.

açıklama

[: */ 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, sağdaki fiilin, ardından soldaki fiilin ardından sağdaki fiilin tersini uygulayan şık bir zarftır . Ayrıca sayılara geri dönüşümü teknik olarak eval ( ".-do) kullanıyor.

Python 2 , 43 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 28 bayt

32-bit tamsayılar için tasarlanmıştır.

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

Test durumları

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 bayt

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

Çevrimiçi deneyin!

Brachylog , 5 bayt

⊇ẹ×ℕ₁

Çevrimiçi deneyin!

açıklama

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

Bu ⊇, büyük alt kümelerden küçük alt kümelere kadar birleştiğinden, bu nedenle sıfır olmayan bir ürünle sonuçlanacak ilk, tüm sıfırların hariç tutulduğu ve başka hiçbir şey olmadığı zamandır.

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

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

Çevrimiçi deneyin!

Java 8, 55 54 53 51 bayt

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

Port @Dennis 'Python 2 cevap . @RiaD
sayesinde -1 bayt .

Burada dene.

55 54 bayt sürümü:

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

Çevrimiçi deneyin.

Julia 0.6, 26 bayt

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

Kullanım örneği:

julia> !54
20

Çevrimiçi deneyin!

JavaScript (Node.js) , 30 bayt

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

Çevrimiçi deneyin!

Alır dize , girdi olarak dizi olarak davranır onu ve dizinin tarafından yapı bozma ilk elemanını ayırır [a,...b]. karaktere +a||1karşılık gelen basamağı döndürür a. Sanırım bu gerisi kendi kendine açıklıyor ..

Octave , 21 bayt

Bir bayt tasarrufu için @Luis Mendo'ya ve başka bir bayt kaydetme için @ alephalpha'ya teşekkürler!

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

Girdiyi rakam dizisi olarak alır.

Çevrimiçi deneyin!

30 bayt:

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

Sayı olarak girdi alır.

Çevrimiçi deneyin!

Beyin Flak , 88 bayt

Okunabilir sürüm:

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

Çevrimiçi deneyin!

Clojure , 56 bayt

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

Oldukça basit. Sayıyı dizgeye dönüştürür, sonra sayılara döndürmek için her karakterden 48 çıkarır. Daha sonra her 0 değerini 1 ile değiştirir ve* değerini değiştirir ve sonuçtaki sayı listesine (* liste üzerinde ). Bir numara veya belirli bir numara kabul edebilir.

Çevrimiçi deneyin!

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

!UXzp

Giriş bir dize olarak alınır

MATL Online'da deneyin ! Veya Çevrimiçi Deneyin'de test durumlarını doğrulayın!

açıklama

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

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

Çevrimiçi deneyin!

açıklama

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 bayt

Sayı dizisi olarak girdi alan, onu bir diziye yayan, daha sonra çarpım yoluyla azaltan veya sonuç 0 ise değeri döndüren Basit Javascript (ES6) yöntemi.

Shaggy sayesinde 3 bayt kurtarıldı

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

Çevrimiçi deneyin!

Ruby, 42 40 35 32 27 bayt

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

Giriş hiçbir yeni satır varsayar Başlıca etkisi

@GolfWolf sayesinde -2 bayt

@Conor O'Brien sayesinde -5 bayt

Java (OpenJDK 8) , 45 bayt

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

Çevrimiçi deneyin!

C # , 97 Bayt (İlk kod 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;}

Bir yöntemle sarmam gerekip gerekmediğinden emin değilim, bu yüzden güvenli olması için dahil edilmedi.

Bir Int alır, onu bir dizgeye dönüştürür ve 0'ları yok sayan karakterlerin her birinin katlarını döndürür. Ascii değerini bir karakter olarak okuduğu gibi kullanan program nedeniyle eksi 48 olması gerekiyordu.

C # (Visual C # Etkileşimli Derleyici) , 46 bayt

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

Çevrimiçi deneyin!

Haskell , 36 bayt

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

Aynı bayt sayısı:

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

Çevrimiçi deneyin!

Jöle , 6 , 5 bayt

ṢU×\Ṁ

Çevrimiçi deneyin!

> <> , 19 bayt

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

Çevrimiçi deneyin!