Bestimmen Sie bei zwei Zahlen N und x die Anzahl der x-stelligen Zahlen, deren Ziffernprodukt N ist

limits: N(<10^6) and x(<12)

Sample Input:
8 3
Sample Output:
10

Python 208 Zeichen

def dec(num, num_dig):
    if num_dig==0:
        return int(num==1)
    else:
        return sum(dec(num/i, num_dig-1) for i in range(1,10) if num/i*i==num)

if __name__ == "__main__":    
    print dec(8,3)

Golfscript 42 31

~10\?.10/\,>{10base{*}*1$=},,\;

Eingabe: Erwartet die Zahlen Nund xals Befehlszeilenargumente (durch Leerzeichen getrennt).

Das Programm kann hier getestet werden .

Brachylog (2), 13 Bytes, Herausforderung nach Sprachdaten

{h.&t~lℕẹ≜×}ᶜ

Probieren Sie es online aus!

Erläuterung

{h.&t~lℕẹ≜×}ᶜ
{          }ᶜ   Count the number of
         ≜      values at this point
   &t           formed via taking the last element of the input,
       ℕ        generating an integer
     ~l         of that length,
        ẹ       and splitting it into digits
          ×     such that the product of those digits
 h.             is the first element of {the input}

Ein netter Golf-Trick, der hier verwendet wird, ist, dass er sich im Gegensatz zu fast allen Metapredikaten ᶜüberhaupt nicht um den tatsächlichen Wert von kümmert .(der normalerweise verwendet wird, um eine Ausgabe für die Metapredikate zu erstellen). kann als solche .wie jede andere Variable verwendet werden (Speichern eines Bytes, da es implizit vorher angezeigt wird }). Da es hier nirgendwo implizite Beschriftungen gibt, musste ich eine explizite Beschriftung hinzufügen ≜, um ᶜetwas zu zählen.

Scala 107:

def f(N:Int,x:Int,s:Int=1):Int=if(s==N&&x==0)1 else
if(s>N||x==0)0 else
((1 to 9).map(i=>f(N,x-1,s*i))).sum

ungolfed, debugfriendly version:

def findProduct (N: Int, sofar: Int, togo:Int, collected:String=""):Int={
  if (sofar == N && togo == 0) {
    println (collected)
    1
  } else
  if (sofar > N || togo == 0) 0 else 
  (1 to 9).map (x=> findProduct (N, sofar*x, togo-1, collected + " " + x)).sum
}

Aufruf mit Debugging-Ausgabe:

scala> findProduct (3, 1, 8)
 1 1 1 1 1 1 1 3
 1 1 1 1 1 1 3 1
 1 1 1 1 1 3 1 1
 1 1 1 1 3 1 1 1
 1 1 1 3 1 1 1 1
 1 1 3 1 1 1 1 1
 1 3 1 1 1 1 1 1
 3 1 1 1 1 1 1 1
res175: Int = 8

scala> findProduct (8, 1, 3)
 1 1 8
 1 2 4
 1 4 2
 1 8 1
 2 1 4
 2 2 2
 2 4 1
 4 1 2
 4 2 1
 8 1 1
res176: Int = 10

Python (arbeitet noch daran) 164

from itertools import *
N,x=map(int,raw_input().split())
print len([c for c in product([d for d in range(1,10)if N%d==0],repeat=x) if reduce(lambda x,y:x*y,c)==N])

C # 128

int Z(int n,int x){var i=(int)Math.Pow(10,x-1);return Enumerable.Range(i,i*9).Count(j=>(j+"").Aggregate(1,(a,c)=>a*(c-48))==n);}

Diese C # -Methode gibt die Anzahl der xeinstelligen Zahlen zurück, deren Ziffernprodukt ist n. Es erfordert, dass Namespaces Systemund System.Linqim aktuellen Kontext importiert werden.

Online-Version: http://ideone.com/0krup

Haskell 117 Zeichen

import Data.Char
main = print $ f 3 8
f n t = length[x|x<-[10^(n-1)..(10^n-1)],foldr(*)1(map digitToInt $ show x)==t]

K, 49

{+/x=*/'"I"$''${x@&~x in y}.!:'"i"$10 xexp y,y-1}

.

k){+/x=*/'"I"$''${x@&~x in y}.!:'"i"$10 xexp y,y-1}[8;3]
10

J, 40 Bytes

[:+/[=[:*/"1(10#~])#:(10^<:@])}.[:i.10^]

Generiert alle x-stelligen Zahlen, konvertiert jede in Basis 10, findet dann das Produkt jeder Zahl und testet, ob jede Zahl gleich der linken Seite ist, und ermittelt dann die Summe jedes Booleschen Werts.

Jelly , 12 Bytes, Herausforderung nach Sprachdaten

,’⁵*r/ḊDP€ċƓ

Probieren Sie es online aus!

Nimmt x als Befehlszeilenargument und N als Standardeingabe.

Erläuterung

,’⁵*r/ḊDP€ċƓ
,             On {the input} and
 ’            {the input} minus 1
  ⁵*          take 10 to the power of each of those numbers
    r/        then form a range between them
      Ḋ       without its first element;
       D      treat each element as a list of digits,
        P€    take the product of each of those digit lists,
          ċ   then count the number of times
           Ɠ  the value from standard input appears

Der schwierige Teil besteht darin, die Liste der Zahlen mit x Ziffern zu generieren . die niedrigste solche Zahl ist 10 ^{x –1} , die höchste ist 10 ^x –1. Der Bereich wird hier erzeugt , indem zuerst das Paar ( x , x −1) erzeugt wird, dann 10 zur Potenz von beiden genommen wird und dann der Bereich zwischen ihnen erzeugt wird. Der Bereich umfasst standardmäßig beide Endpunkte. Nur für den Fall, dass N zufällig 0 ist, müssen wir das obere Ende des Bereichs (der zuerst kommt, weil es ein "Rückwärts" -Bereich ist) mit entfernen Ḋ.