Olumlu bir tamsayı alın X. Bu numara, her basamak toplamı ise ilgilenen sekansının parçası olan Xbir bölen bir Xve her basamak ürünü halinde Xbir bölen bir X.

Örneğin 135, böylesi bir sayıdır, çünkü 1 + 3 + 5 = 9bölen 135 = 9 * 15ve 1 * 3 * 5 = 15bölen de 135.

Bu, OEIS'deki A038186 dizisidir .

Göreviniz: bir tamsayı verildiğinde N, Nbu tür özelliklere sahip th pozitif bir tamsayı çıktısı alın .

Girdiler ve çıktılar

• Sayılar 0-dekslenmiş veya 1-dekslenmiş olabilir; Lütfen cevaplarınızın hangisini kullandığını belirtin.

• Girdi, STDINbir işlev argümanı veya benzer bir şey olarak alınabilir .

• Çıktı, STDOUTbir işlevden veya benzeri bir şeyden yazdırılabilir .

Test durumları

Aşağıdaki test vakaları 1-gelişmiştir.

Input        Output

1            1
5            5
10           12
20           312
42           6912
50           11313

puanlama

Bu kod golf , yani bayt cinsinden en kısa cevap kazanır.

05AB1E , 13 12 bayt

Bir bayt kaydettiğiniz için Emigna için teşekkürler !

µNNSONSP‚ÖP½

Açıklama:

µ          ½   # Get the nth number for which the following holds:
  NSO          #   The sum of digits of the current number
     NSP       #   And the products of digits of the current number
 N      ‚ÖP    #   Divides the current number
               # If the nth number has been reached, quit and implicitly print N

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Pyke, 14 bayt (rekabetçi olmayan) (1 indeksli)

~1IY'sB]im%X)@

Burada dene!

Tanrım, ne çok yeni özellik.

~1             -   infinite list of natural numbers
  IY'sB]im%X)  -  filter(^, V) - remove if any truthiness
   Y           -      digits(i)
    'sB]       -     [sum(^), product(^)]
        im%    -    map(^, %i)
           X   -   splat(^)
             @ - ^[input]

Hangi rekabet dışı

• bir bugfix Iyığını ilk madde truthy olsaydı sadece çek nerede
• digits - numaradaki rakamların listesini döndür
• @ sonsuz bir listenin ’maddesini almak için kullanılır

Bunlardan ilk kez kullanılıyordu:

• Yukarıdakilerin hepsi
• sonsuz listeler

Tüm bu sayıları almak için son 2 baytı kaldırın.

C #, 118 bayt

n=>{int x=0,c=0;for(;;){int s=0,p=1,i=++x;while(i>0){s+=i%10;p*=i%10;i/=10;}if((c+=p>0&&x%s+x%p<1?1:0)==n)return x;}};

Ungolfed fonksiyon ve test vakaları ile tam program:

using System;

public class Program
{
    public static void Main()
    {
        // x - output number
        // c - counter
        // s - sum
        // p - product
        // i - iterator
        Func<int,int>f= n=>
        {
            int x=0, c=0;
            for ( ; ; )
            {
                int s=0, p=1, i=++x;
                while (i > 0)
                {
                    s += i%10;
                    p *= i%10;
                    i /= 10;
                }
                if ( (c += p> 0&& x%s+x%p<1 ? 1 : 0) == n)
                    return x;
            }
        };

        // tests:
        Console.WriteLine(f(1));  //1
        Console.WriteLine(f(5));  //5
        Console.WriteLine(f(10)); //12
        Console.WriteLine(f(20)); //312
        Console.WriteLine(f(42)); //6912
        Console.WriteLine(f(50)); //11313
    }
}

Jöle , 13 bayt

DµP;SðḍȦ
1Ç#Ṫ

1 tabanlı.
TryItOnline!

Nasıl?

DµP;SðḍȦ - Link 1, test a number
D        - convert to a decimal list
 µ       - monadic chain separation
   ;     - concatenate the
  P      -     product, and the
    S    -     sum
     ð   - dyadic chain separation
      ḍ  - divides n?
       Ȧ - all (i.e. both)

1Ç#Ṫ - Main link, get nth entry, 1-based: n
1 #  - find the first n matches starting at 1 of
 Ç   - the last link (1) as a monad
   Ṫ - tail (the ultimate result)

Perl 6 , 44 bayt (0 dizinli)

{grep({$_%%(.comb.sum&[*] .comb)},1..*)[$_]}

Açıklama:

{                                          }  # A function, with an argument n (`$_`)
 grep(                           ,1..*)       # Filter the infinite list
      {$_                       }             # Check that the function's argument
         %%(                   )              # is divisible by
                     &                        # both:
            .comb.sum                         # - the sum of the digits
                      [*] .comb               # - the product of the digits
                                       [$_]   # Get the n-th value

Sonsuz ftw listeler!

Aslında , 20 bayt

Dizi tanımının saf uygulanması. Golf önerileri hoş geldiniz! Çevrimiçi deneyin!

u`;;$♂≈;Σ(%@π(%|Y`╓N

Ungolfing

         Implicit input n.
u        Increment n, so that we don't accidentally include 0 in the sequence.
`...`╓   Starting with x=0, return the first n+1 values of x where f(x) is truthy.
  ;;       Duplicate x twice.
  $♂≈      str(x) and convert each char (each digit) into an int. Call this digit_list.
  ;        Duplicate digit_list.
  Σ        Get sum(digit_list).
  (%       Get x % sum(digit_list), which returns 0 if sum is a divisor of x.
  @        Swap the other duplicate of digit_list to TOS.
  π        Get prod(digit_list).
  (%       Get x % prod(digit_list), which returns 0 if prod is a divisor of x.
  |        Get x % sum(digit_list) OR x % prod(digit_list).
  Y        Logical negate, which only returns 1 if both are divisors, else 0.
N        Return the last value in the list of x where f(x) is truthy,
          that is, the nth value of the sequence.

Denizanası , 45 bayt

p
\Ai
\&
>(&]&|0
  <*&d
 &~bN
  10
 ( )/+
 /*

Çevrimiçi deneyin!

açıklama

Bu, şu ana kadar Jellyfish'te yazdığım en ayrıntılı (ve aynı zamanda en uzun program) program. Bunu anlaşılır bir şekilde çözebilecek miyim, hiçbir fikrim yok, ama denemek zorundayım sanırım.

Denizanası \"Nth şey bulma" konusunda çok yardımcı olan oldukça genel bir yineleme operatörü sağlar . Anlambilimcilerinden biri "ayrı bir test işlevi bir şeyler gerçeğe varana kadar bir değer üzerinde bir işlevi yinelemektir" (aslında, test işlevi hem akımı hem de son öğeyi alır, ancak yalnızca mevcut öğeye bakacağız) . Bunu "bir sonraki geçerli sayı" işlevini uygulamak için kullanabiliriz. Bir başka aşırı yüklenme \"N kere başlangıç ​​değerindeki bir fonksiyonu yinelemektir". Önceki fonksiyonumuzu kullanabilir ve 0N defa gireriz ; burada N, girişdir. Bunların hepsi, kodun bu kısmı ile tam bir şekilde kurulmuştur:

p
\Ai
\&
>     0

( 0Sonuçta ortaya çıkan işlevin asıl girişinin nedenleri bitmiştir, burada biraz karışık ve bunlara girmeyeceğim.)

Tüm bunlarla ilgili sorun şu ki, mevcut değeri test fonksiyonuna manuel olarak aktarmayacağız. \Operatör bizim için yapacağız. Bu yüzden şimdi bir sayı alan ve geçerli bir sayı olup olmadığını söyleyen tek bir tekli fonksiyon (kompozisyonlar, kancalar, çatallar ve saç kurutma makinesi) kurduk. Bu, tartışmaya atıfta bulunmadığınızda oldukça önemsizdir. Hiç. Bu güzellik:

 (&]&|
  <*&d
 &~bN
  10
 ( )/+
 /*

(Bir tekli bir kanca aşağıda fonksiyon (çağırır araçları, fkendi girişi) (akım değeri x) ve ardından sağa doğru (test işlevine her ikisi de geçer gbu hesaplar olan), g(f(x), x).

Bizim durumumuzda, f(x)rakam ürün ve rakam toplamı ile bir çift elde eden başka bir bileşik fonksiyondur x. Bu , geçerli golup olmadığını kontrol etmek için üç değerin de bulunduğu bir işlev anlamına gelir x.

fRakam toplamının ve rakam ürününün nasıl hesaplandığına bakarak başlayacağız . Bu f:

 &~b
  10
 ( )/*
 /+

&aynı zamanda kompozisyondur (ama tam tersidir). ~Körleme işlemi 10~bbir sayının ondalık basamağını hesaplayan bir işlev verir ve bunu &sağdan geçirdiğimizden beri , girişte gerçekleşecek ilk şey budur x. Kalan kısım, toplamını ve ürününü hesaplamak için bu rakam listesini kullanır.

Bir toplamı hesaplamak için, üzerine katlama yapabiliriz /+. Aynı şekilde, ürünü hesaplamak için çarpma işlemini bunun üzerine katlıyoruz /*. Bu sonuçların her ikisini de bir çift halinde birleştirmek için bir çift kanca kullanırız (ve ). Bunun yapısı:

()g
f

(Nerede fve gsırasıyla, ürün ve toplamıdır.) Bu bize bir çift verir neden edelim deneyin anlamaya f(x)ve g(x). Sağ kancanın )sadece bir argüman olduğuna dikkat edin . Bu durumda, diğer argüman, ;argümanlarını bir çifte sardığı anlamına gelir. Ayrıca, kancalar ikili fonksiyonlar olarak da kullanılabilir (buradaki durum bu olacaktır), bu durumda iç fonksiyonu sadece bir argümana uygularlar. Yani gerçekten )tek gbir fonksiyon üzerinde hesaplayan bir fonksiyon verir [x, g(y)]. Bunu sol kancayla birlikte kullanarak felde ediyoruz [f(x), g(y)]. Bu, sırayla, tek bir bağlamda kullanılır, bu aslında onunla çağrıldığı x == yve dolayısıyla gerektiği gibi sonuçlandığımız anlamına gelir [f(x), g(x)]. Uf.

Bu, daha önceki test fonksiyonumuz olan tek bir şey bırakır g. Halen geçerli giriş değerinin g([p, s], x)neresi olarak çağrılacağını , rakam ürününün ve rakam toplamının olduğunu hatırlayın . Bu :xpsg

  &]&|
  <*&d
    N

Bölünebilirliği test etmek için, açıkça |Denizanası'ndaki modulo'yu kullanacağız . Biraz alışılmadık bir şekilde, sağ operand modülünü sol operandını alır, yani argümanlar gzaten doğru sıradadır (bunun gibi aritmetik fonksiyonlar otomatik olarak listelerde yer alır, bu nedenle bu iki ayrı modülü ücretsiz olarak hesaplar) . Sonuç bir çift sıfırsa, sayımız hem ürün hem de toplam tarafından bölünebilir. Durumun böyle olup olmadığını kontrol etmek için, çifte baz-2 rakamlarının ( d) bir listesi gibi davranıyoruz . Bunun sonucu sıfırdır, sadece çiftin her iki öğesi de sıfır olduğunda, bu nedenle Nher iki değerin girişi bölüşüp bölmediğine ilişkin bir gerçek değer elde etmek için bunun ( ) sonucunu ihmal edebiliriz. Not |, dveNsadece hepsi bir çift &s ile birlikte oluşur .

Ne yazık ki, tam hikaye bu değil. Rakam ürün sıfırsa ne olur? Bölünme ve modulo sıfır olarak Denizanası'nda sıfıra geri döner. Bu biraz garip bir kongre gibi görünse de, aslında biraz faydalı olduğu ortaya çıkıyor (çünkü modulo yapmadan önce sıfırı kontrol etmemize gerek yok). Bununla birlikte, rakam toplamı girişi böldüğü halde yanlış bir artı değer alabileceğimiz anlamına gelir, ancak rakam ürün sıfırdır (örneğin, giriş 10).

Bunu, bölünebilirlik sonucumuzu rakam ürünüyle çarparak düzeltebiliriz (eğer rakam rakam sıfırsa, gerçeğe uygun değerimizi de sıfıra çevirir). Bölünebilirlik sonucunu ürün çifti ve toplamı ile çarpmak ve sonucu daha sonra üründen çıkarmak daha basit hale geldi.

Sonucu parite ile çarpmak için daha erken bir değere (parite) geri dönmemiz gerekir. Bu bir çatalla ( ]) yapılır. Çatallar steroidlerin kancası gibidir. Onlara iki işlevi verirsek fve gbunlar hesaplar ikili işlevini temsil f(a, g(a, b)). Bizim durumumuzda aürün / toplam çifti, bmevcut girdi değeri, gbölünebilirlik testimiz ve çarpımdır f. Yani tüm bu hesaplar [p, s] * ([p, s] % x == [0, 0]).

Şimdi kalan tek şey, iteratörde kullanılan test fonksiyonunun son değeri olan ilk değerini çıkarmak. Bu, listenin ilk değerini döndüren kafa işlevli &çatalı beslemek ( ) kadar basittir .<

R, 132 115 bayt

@Billywob güzel yorum sayesinde yeni sürüm!

n=scan();b=i=0;while(i<n){b=b+1;d=strtoi(el(strsplit(c(b,""),"")));if(na.omit(c(!b%%sum(d)&!b%%prod(d),0)))i=i+1};b

Ungolfed:

n=scan()
b=i=0

while(i<n)
    b=b+1;
    d=strtoi(el(strsplit(c(b,""),""))) #Splitting the number into its digits

    if(na.omit(c(!b%%sum(d)&!b%%prod(d),0)))
        i=i+1
b

Yana R ile davranırlar strangley NAs, ben bütün eklemek zorunda ifelse(is.na(...))parçasını!
Veya kullanna.omit(...)

Brachylog , 22 bayt

:1yt
#>=.@e+:I*.@e*:J*

Çevrimiçi deneyin!

açıklama

:1y                    Evaluate the first N valid outputs to the predicate below given the
                         main input as input
   t                   The output is the last one


#>=.                  Output is a strictly positive integer
    @e+               The sum of its digits…
       :I*.           …multiplied by an integer I results in the Output
           @e*        The product of its digits…
              :J*     …multiplied by an integer J results in the Output

JavaScript (ES6), 78

n=>eval("for(i=0;n;!p|i%s|i%p||n--)[...++i+''].map(d=>(s-=d,p*=d),s=0,p=1);i")

Daha az golf oynadı

n=>{
  for(i=0; n; !p|i%s|i%p || n--)
    s=0,
    p=1,
    [...++i+''].map(d=>(s-=d, p*=d));
  return i
}  

Pyth, 18 bayt

e.f!.xs%LZsM*FBsM`

Çevrimiçi deneyin: Gösteri

Açıklama:

e.f!.xs%LZsM*FBsM`ZZQ1   implicit variables at the end
e                        print the last number of the 
 .f                 Q1   first Q (input) numbers Z >= 1, which satisfy:
                 `Z         convert Z to a string, e.g. "124"
               sM           convert each digits back to a number, e.g. [1, 2, 4]
            *FB             bifurcate with product, e.g. [[1, 2, 4], 8]
          sM                take the sum of each, e.g. [7, 8]
       %LZ                  compute the modulo of Z with each number, e.g. [5, 4]
      s                     and add both numbers, e.g. 9
    .x             Z        if an exception occurs (mod 0), use number Z instead
   !                        test, if this number is zero

JavaScript (ES6), 72 bayt

k=>eval("for(n=0;(E=o=>n%eval([...n+''].join(o))!=0)`+`|E`*`||--k;)++n")

gösteri

Daha yüksek değerler için yavaş olma eğilimindedir, bu yüzden burada 20 ile sınırlandırıyorum.

let f =

k=>eval("for(n=0;(E=o=>n%eval([...n+''].join(o))!=0)`+`|E`*`||--k;)++n")

console.log(f(1));  // 1
console.log(f(5));  // 5
console.log(f(10)); // 12
console.log(f(20)); // 312

Haskell, 94 85 72 71 bayt

([n|n<-[0..],(==)=<<map(gcd n)$[product,sum]<*>[read.pure<$>show n]]!!)

1 endeksli.

13 byte tasarruf için @ Zgarb teşekkürler!

Bir bayt tasarrufu için @nimi teşekkürler!

MATL , 21 bayt

`@tFYAtswph\~?@]NG<]&

Uzun ve verimsiz ...

Çevrimiçi deneyin!

Nasıl çalışır

`        % Do...while
  @      %   Push current iteration index (1-based)
  tFYA   %   Duplicate. Convert number to its digits
  ts     %   Duplicate. Sum of digits
  wp     %   Swap. Product of digits
  h\     %   Concatenate. Modulo. This gives a length-2 array
  ~?     %   If the two values are zero: we found a number in the sequence
    @    %     Push that number
  ]      %   End if
  NG<    %   True if number of elements in stack is less than input
]        % End do...while. If top of the stack is true: next iteration. Else: exit
&        % Specify only one input (top of stack) for implicit display

JavaScript (ES6), 70 bayt

k=(b,n=1,f=c=>n%eval([...n+''].join(c))!=0)=>f`+`|f`*`||--b?k(b,n+1):n

Bu @ Arnauld'un cevabı gibi biraz ortaya çıktı, ancak özyineleme görünüşte 2 bayt daha kısa. Chrome'da çalışır, ancak 30'dan fazla veya daha büyük girişlerde çok yavaş (50, 6 saniye sürer).

Python 2, 122 110 Bayt

def a(m,i=1,k=1):n=map(int,`i`);p=reduce(lambda x,y:x*y,n);k+=p and 1>i%sum(n)+i%p;return(k>m)*i or a(m,i+1,k)

1 endeksli, oldukça yüksek özyineleme limiti olan bir Python tercüman kullanmanız gerekir.

Wonder, 33 bayt

@:^#0(!>@!(| %#0sum#0)%#0prod#0)N

Sıfır endekslendi. Kullanımı:

(@:^#0(!>@!(| %#0sum#0)%#0prod#0)N)9

açıklama

Daha okunabilir:

@
  iget #0 
    (fltr@
      not (or % #0 sum #0) % #0 prod #0
    ) N

Temel olarak, sayısal bir toplamı ve ürünüyle bölünebilen sayılar listesini, bir yordam aracılığıyla sayısız tam sayı listesini filtreleyerek alır. Ardından nth maddesi basitçe listeden çıkarılır.

Julia, 81 bayt

n->(i=c=1;while c<n d=digits(i+=1);all(d.>0)&&i%sum(d)==i%prod(d)<1&&(c+=1)end;i)

Bu bir tamsayıyı kabul eden ve bir tamsayı döndüren adsız bir işlevdir. Aramak için bir isim verin. Buradaki yaklaşım açık olanıdır: Her bir sayıyı ndizilim terimleriyle karşılaşana kadar kontrol edin . allÇek bir alamadım sağlamak için gereklidir DivisionErrorgelen% basamak ürünü 0 olduğunda.

Ungolfed:

function f(n)
    i = c = 1
    while c < n
        d = digits(i += 1)
        all(d .> 0) && i % sum(d) == i % prod(d) < 1 && (c += 1)
    end
    return i
end

Çevrimiçi deneyin! (tüm test durumlarını içerir)

C89, 381 226 195 170 169 bayt

1 indeksli (meydan okumadakiyle aynı kesin cevaplar).

4 bayt (32 bit) varsayarint (en modern mimariler) .

Bunun daha kısa süremeyeceğine gerçekten inanıyorum.

x,c,*b,m,t,i,a;g(n){for(b=malloc(0);c<n;b[c-1]=x++,t=1){char s[9];for(i=m=0;i<sprintf(s,"%d",x);m+=a,t*=a)a=s[i++]-48;b=m*t?x%m+x%t?b:realloc(b,4*++c):b;}return b[c-1];}

fonksiyon int g (int) bellek sızdırıyor ve arama başına bir kez başlatılmamış belleğe erişiyor, ancak hatalı arama yapıyor ve doğru numarayı döndürüyor.

./prog $(seq 1 10)Ungolfed (tür) ile unary ( 10 için) girdi alır Tam program :

x, c, * b, m, t, i, a;

g(n) {
 for (b = malloc(0); c < n; b[c - 1] = x++, t = 1) {
  char s[9];
  i = m = 0;
  for (; i < sprintf(s, "%d", x); m += a, t *= a) a = s[i++] - 48;
  b = m * t ? x % m + x % t ? b : realloc(b, 4 * ++c) : b;
 }
 return b[c - 1];
}

main (j) {
  printf("%d\n", g(--j));
}

Eski cevap:

C99, 381 bayt

#include <stdio.h>
#include <inttypes.h>
#include <string.h>
#include <stdlib.h>
#define U uint64_t
#define S size_t
S f(S n){U x=0;S c=1,l;U*b=malloc(sizeof(U));while(c<=n){char s[21];snprintf(s,20,"%"PRIu64,x);U m=0,t=1;l=strnlen(s,21);for(S i=0;i<l;i++){U a=(U)s[i]-48;m+=a,t*=a;}if(m*t?(!(x%m))&&(!(x%t)):0){b=realloc(b,sizeof(U)*++c);b[c-1]=x;}++x;}U o=b[n];free(b);return o;}

Bu muhtemelen daha çok golf oynayabilir.

Tam program:

#include <stdio.h>
#include <limits.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>

bool qualifies (const uint64_t);
size_t       f (const size_t);


int main(const int argc, const char* const * const argv) {
  (void) argc;
  size_t arg = strtoull(argv[1], NULL, 10);
  uint64_t a = f(arg);
  printf("a: %" PRIu64 "\n", a);
  return 0;
}

bool qualifies (const uint64_t num) {
  char s[21];
  snprintf(s, 20, "%" PRIu64 "", num);

  uint64_t sum  = 0,
           mult = 1;
  size_t    len = strnlen(s, 400);

  for (size_t i = 0; i < len; i++) {
    uint64_t a = (uint64_t) s[i] - 48;
    sum += a, mult *= a;
  }

  //printf("sum: %" PRIu64 "\nmult: %" PRIu64 "\n", sum, mult);
  return sum * mult ? (! (num % sum)) && (! (num % mult)) : false;
}

size_t f (const size_t n) {
  uint64_t x = 0;
  size_t s_len = 1;
  uint64_t* nums = malloc(sizeof (uint64_t) * s_len);

  while (s_len <= n) {
    if (qualifies(x)) {
      ++s_len;
      //printf("len: %zu\n", s_len);
      nums = realloc(nums, sizeof (uint64_t) * s_len);
      nums[s_len - 1] = x;
    }
    ++x;
  }

  uint64_t o = nums[n];
  free(nums);
  return o;
}

C, 110 bayt

p;s;i;j;f(n){j=0;while(n){i=++j;p=1;s=0;do p*=i%10,s+=i%10;while((i/=10)>0);if(p>0&&j%p+j%s==0)--n;}return j;}

Ungolfed ve kullanım:

p;s;i;j;
f(n){
 j=0;
 while(n){
  i=++j;
  p=1;
  s=0;
  do
   p*=i%10,   //product
   s+=i%10;   //sum
  while((i/=10)>0);
  //check if product is not zero since floating point exception
  if(p>0 && j%p + j%s == 0)--n;
 }
 return j;
}

int main(){
 int n;
 scanf("%d",&n);
 printf("\n%d\n", f(n));
}

Python3, 134 80 Bayt

Flp.Tkc sayesinde yeni sürüm

t=input();h=k=0;p=int
def g(x,q=0,w=1):
    for i in x:X=p(x);I=p(i);q+=I;w*=I
    return w!=0and X%q+X%w<1
while h<p(t):k+=1;h+=g(str(k))

Yeni kod, faktoringi yapmanın bir golf yolunu hatırladım

f,t=lambda x:0**x or x*f(x-1),0
for i in str(f(int(input()))):t+=int(i)
print(t)

Kod kendisi çok golf gibi değil, kaba kuvvet golf gibi

def g(x):
    q=0;w=1;X=int(x)
    for i in x:I=int(i);q+=I;w*=I
    return (w!=0+ X%q==0and X%w==0)
t=input();h=k=0
while h<int(t):
    k+=1
    if g(str(k))is True:h+=1

g (x), x ölçütlere uygunsa True döndüren bir işlevdir.

PHP, 96 bayt

Alır nbir komut satırı argümanı olarak.

golfed

for(;$i<$argv[1];)!($p=array_product($d=str_split(++$j)))|$j%array_sum($d)||$j%$p?:$i++;echo $j;

Ungolfed

for (; $i < $argv[1];)                             // Loop until we've found the nth number as pass by command line
    !($p = array_product($d = str_split(++$j))) || // Split our current number into its digits and assign that to a variable, then assign the product of that array to another variable.
                                                   // As well, we're checking if the product equals 0, to prevent an error from trying to mod by 0 later. The condition short circuits before it happens.
    $j % array_sum($d) ||                          // Check if the sum of the array is a divisor
    $j % $p                                        // Check if the product is a divisor
    ?: $i++;                                       // Increment the number of found instances only if all conditions are met.
echo $j;                                           // Output to screen.

PowerShell v2 +, 84 bayt

param($n)for(;$n){$n-=!(++$a%(($b=[char[]]"$a")-join'+'|iex)+$a%($b-join'*'|iex))}$a

Yinelemeli çözüm. Girdiyi alır $nve sıfır olmadığı forsürece bir döngüye girer $n. Her yinelemede, $nbir Boolean ifadesinin sonucundan çıkarıldıkça, aşağıdakiler ayrıldı:

!(++$a%(($b=[char[]]"$a")-join'+'|iex)+$a%($b-join'*'|iex))
!(                                                        ) # Encapsulate in a NOT
  ++$a%                                                     # Increment $a and take mod ...
        ($b=[char[]]"$a")                                   # Turn $a into char-array, store in $b
                         -join'+'                           # Join the char-array together with +
                                 |iex                       # and eval it
                                      $a%($b-join'*'|iex)   # Similar for *
                                     +                      # Addition

Bu nedenle, yalnızca sıfıra eşitse $a%(sum)ve $a%(product)her ikisi de sıfıra eşitse, ekleme de sıfır olur ve bu nedenle Boole-Doğru değildir ve bu nedenle $nazalır.

Döngüden çıktıktan sonra (yani, ns terimine basarız ), sadece $aboru hattına yerleştiririz ve çıktı kapalıdır.

Örnekler

Not: Bu , varsayılan olarak yok sayılan STDERR'ye bir demet "Sıfırla bölme girişimi" hatası veriyor. 2>$nullÇıktıyı temizlemek için aşağıdaki örneğe açıkça ekledim . Aynı zamanda yaklaşık 30ya da öylesine bir kez alır ve 50makinemde yaklaşık 45 saniye sürer oldukça yavaş .

PS C:\Tools\Scripts\golfing> 1,5,10,20,30,42,50|%{"$_ --> "+(.\numbers-divisible-by-sum-and-product.ps1 $_ 2>$null)}
1 --> 1
5 --> 5
10 --> 12
20 --> 312
30 --> 1344
42 --> 6912
50 --> 11313

BASH, 125 bayt

while ((n<$1));do
((i++))
p(){ fold -1<<<$i|paste -sd$1|bc;}
z=`p \*`
((z))&&[ $[i%`p +`]$[i%z] -eq 0 ]&&((n++))
done
echo $i