Weź dodatnią liczbę całkowitą X. Ta liczba jest częścią sekwencji, która nas interesuje, jeśli suma wszystkich cyfr Xjest dzielnikiem X, a jeśli iloczyn wszystkich cyfr Xjest dzielnikiem X.

Na przykład 135jest taką liczbą, ponieważ 1 + 3 + 5 = 9która dzieli, 135 = 9 * 15a 1 * 3 * 5 = 15która również dzieli 135.

Jest to sekwencja A038186 w OEIS.

Twoje zadanie: biorąc pod uwagę liczbę całkowitą N, wypisz Nth dodatnią liczbę całkowitą o takich właściwościach.

Wejścia i wyjścia

• Liczby mogą być 0indeksowane lub 1indeksowane; proszę wskazać, którego z nich używa Twoja odpowiedź.

• Dane wejściowe mogą być pobierane STDINjako argument funkcji lub coś podobnego.

• Wyjście może być wydrukowane STDOUT, zwrócone z funkcji lub coś podobnego.

Przypadki testowe

Przypadki testowe poniżej są 1indeksowane.

Input        Output

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

Punktacja

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

05AB1E , 13 12 bajtów

Dzięki Emignie za uratowanie bajtu!

µNNSONSP‚ÖP½

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Pyke, 14 bajtów (niekonkurencyjny) (1-indeksowany)

~1IY'sB]im%X)@

Wypróbuj tutaj!

Mój Boże, wiele nowych funkcji.

~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]

Z których są niekonkurencyjne

• poprawka błędu w I którym byłoby to sprawdzić tylko wtedy, gdy pierwszy element na stosie było truthy
• digits - zwraca listę cyfr w numerze
• @ używane, aby uzyskać n-ty element nieskończonej listy

Z których zastosowano po raz pierwszy:

• wszystkie powyższe
• nieskończone listy

Usuń ostatnie 2 bajty, aby uzyskać wszystkie te liczby.

C #, 118 bajtów

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

Pełny program z funkcją niepolowania i przypadków testowych:

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

Galaretka , 13 bajtów

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

Na podstawie 1.
TryItOnline!

W jaki sposób?

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 bajty (indeksowane 0)

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

Wyjaśnienie:

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

Nieskończone listy ftw!

Właściwie 20 bajtów

Naiwna implementacja definicji sekwencji. Zapraszamy do gry w golfa! Wypróbuj online!

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.

Meduza , 45 bajtów

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

Wypróbuj online!

Wyjaśnienie

To zdecydowanie najbardziej rozbudowany (i zarazem najdłuższy) program, jaki do tej pory napisałem w Jellyfish. Nie mam pojęcia, czy będę w stanie to naprawić w zrozumiały sposób, ale chyba będę musiał spróbować.

Meduza zapewnia dość ogólny operator iteracji \, który bardzo pomaga w „znalezieniu N-tego czegoś ”. Jedną z jego semantyek jest „iteracja funkcji na wartości, dopóki osobna funkcja testowa nie da czegoś prawdziwego” (w rzeczywistości funkcja testowa odbiera zarówno bieżący, jak i ostatni element, ale sprawimy, że spojrzy tylko na bieżący element) . Możemy to wykorzystać do zaimplementowania funkcji „następny ważny numer”. Kolejnym przeciążeniem \jest „iteracja funkcji na wartości początkowej N razy”. Możemy użyć naszej poprzedniej funkcji i iterować ją 0N razy, gdzie N jest wejściem. Wszystko to jest skonfigurowane dość zwięźle z tą częścią kodu:

p
\Ai
\&
>     0

(Powody, dla 0których faktyczne dane wejściowe do wynikowej funkcji są tam, są nieco skomplikowane i nie będę tu wchodził.)

Problem polega na tym, że nie będziemy ręcznie przekazywać bieżącej wartości do funkcji testowej. \Operator zrobi to za nas. Mamy teraz skonstruowaną pojedynczą funkcję jednoargumentową (poprzez kompozycje, haczyki, widelce i curry), która pobiera liczbę i mówi nam, czy jest to poprawna liczba (tj. Ta, która jest podzielona przez sumę cyfr i iloczyn cyfrowy). Jest to dość nietrywialne, gdy nie można odnieść się do argumentu. Zawsze. To jest to piękno:

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

(To jednoskładnikowa, hak , co oznacza, że wywołuje funkcję (poniżej f) na wejściu (wartość bieżąca x), a następnie przechodzi oboje do funkcji testowej w prawo ( g), to jest to oblicza g(f(x), x).

W naszym przypadku f(x)jest to kolejna funkcja złożona, która uzyskuje parę z iloczynem cyfr i sumą cyfr x. Oznacza to, gże będzie funkcją, która ma wszystkie trzy wartości, aby sprawdzić, czy xjest poprawna.

Zaczniemy od przyjrzenia się, jak foblicza sumę cyfr i iloczyn cyfrowy. To jest f:

 &~b
  10
 ( )/*
 /+

&to także kompozycja (ale na odwrót). ~jest curry, więc 10~bdaje funkcję, która oblicza cyfry dziesiętne liczby, a ponieważ przekazujemy to &od prawej, to pierwsza rzecz, która stanie się z danymi wejściowymi x. Pozostała część wykorzystuje tę listę cyfr do obliczenia ich sumy i produktu.

Aby obliczyć sumę, możemy nad nią dodać wartość dodaną, to znaczy /+. Podobnie, aby obliczyć iloczyn, składamy na nim mnożenie /*. Aby połączyć oba te wyniki w parę, używamy pary haczyków (i ). Struktura tego jest następująca:

()g
f

(Gdzie fi gsą odpowiednio iloczynem i sumą.) Spróbujmy dowiedzieć się, dlaczego daje nam to parę f(x)i g(x). Zauważ, że prawy haczyk )ma tylko jeden argument. W tym przypadku sugerowany jest drugi argument, ;który owija swoje argumenty w parę. Ponadto haki mogą być również używane jako funkcje binarne (co będzie miało miejsce w tym przypadku), w którym to przypadku po prostu stosują funkcję wewnętrzną tylko do jednego argumentu. Tak naprawdę )na jednej funkcji gdaje funkcję, która się oblicza [x, g(y)]. Używając tego w lewym haczyku, wraz z f, otrzymujemy [f(x), g(y)]. To z kolei jest używane w kontekście jednoargumentowym, co oznacza, że ​​tak naprawdę jest wywoływane za pomocą, x == ywięc kończymy [f(x), g(x)]na wymaganym. Uff

Pozostaje tylko jedna rzecz, która była naszą wcześniejszą funkcją testową g . Przypomnijmy, że będzie on wywoływany, ponieważ g([p, s], x)gdzie xwciąż jest aktualna wartość wejściowa, pjest to iloczyn cyfrowy i ssuma cyfr. To jest g:

  &]&|
  <*&d
    N

Aby przetestować podzielność, oczywiście użyjemy modulo, które znajduje się |w meduzach. Niecodziennie bierze swój prawostronny modulo lewostronny, co oznacza, że ​​argumenty gsą już we właściwej kolejności (funkcje arytmetyczne takie jak ten automatycznie przewijają listy, więc to obliczy dwa osobne moduły za darmo) . Nasza liczba jest podzielna przez iloczyn produktu i sumy, jeśli wynikiem jest para zer. Aby sprawdzić, czy tak jest, traktujemy tę parę jako listę cyfr składających się z 2 cyfr ( d). Wynik tego wynosi zero, tylko gdy oba elementy pary są równe zero, więc możemy zanegować wynik this ( N), aby uzyskać prawdziwą wartość, czy obie wartości dzielą dane wejściowe. Należy zauważyć, że |, diNsą po prostu złożone razem z parą &s.

Niestety, to nie jest pełna historia. Co jeśli iloczyn cyfrowy to zero? Dzielenie i modulo przez zero zwracają zero w meduzach. Chociaż może się to wydawać nieco dziwną konwencją, w rzeczywistości okazuje się być nieco przydatne (ponieważ nie musimy sprawdzać zera przed wykonaniem modulo). Oznacza to jednak również, że możemy uzyskać fałszywie dodatni wynik, jeśli suma cyfr dzieli dane wejściowe, ale iloczyn cyfrowy wynosi zero (np. Dane wejściowe 10).

Możemy to naprawić, mnożąc nasz wynik podzielności przez iloczyn cyfrowy (więc jeśli iloczyn cyfrowy to zero, to zmieni naszą prawdziwą wartość również na zero). Okazuje się, że łatwiej jest pomnożyć wynik podzielności przez parę produktu i sumę, a następnie wyodrębnić wynik z produktu.

Aby pomnożyć wynik przez parę, musimy nieco wrócić do wcześniejszej wartości (pary). Odbywa się to za pomocą fork ( ]). Widelce są trochę jak haczyki na sterydach. Jeśli dasz im dwie funkcje fi g, reprezentują one funkcję binarną, która się oblicza f(a, g(a, b)). W naszym przypadku ajest to para produkt / suma, bjest bieżącą wartością wejściową, gjest naszym testem podzielności i fjest pomnożeniem. Wszystko to oblicza[p, s] * ([p, s] % x == [0, 0]) .

Teraz pozostaje tylko wyodrębnić pierwszą wartość tego, która jest końcową wartością funkcji testowej użytej w iteratorze. Jest to tak proste, jak skomponowanie ( &) rozwidlenia za pomocą funkcji head< , która zwraca pierwszą wartość listy.

R, 132 115 bajtów

Nowa wersja dzięki ładnym komentarzom @Billywob!

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

Nie golfowany:

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

Ponieważ R zachowują się dziwnie z NAs, musiałem dodać całą ifelse(is.na(...))część!
Albo użyjna.omit(...)

Brachylog , 22 bajty

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

Wypróbuj online!

Wyjaśnienie

: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")

Mniej golfa

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 bajtów

e.f!.xs%LZsM*FBsM`

Wypróbuj online: demonstracja

Wyjaśnienie:

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 bajty

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

Próbny

Przy wyższych wartościach jest on raczej powolny, więc ograniczam go tutaj do 20.

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 bajtów

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

1-indeksowany.

Dzięki @Zgarb za uratowanie 13 bajtów!

Dzięki @nimi za uratowanie bajtu!

MATL , 21 bajtów

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

Długi i nieefektywny ...

Wypróbuj online!

Jak to działa

`        % 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 bajtów

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

Okazało się to trochę jak odpowiedź @ Arnaulda, ale rekurencja jest najwyraźniej o 2 bajty krótsza. Działa w Chrome, chociaż jest bardzo wolny na wejściach większych niż 30 lub mniej (50 zajmuje 6 sekund).

Python 2, 122 110 bajtów

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 zindeksowany, musisz użyć interpretera języka Python z dość wysokim limitem rekurencji.

Cud, 33 bajty

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

Zero indeksowane. Stosowanie:

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

Wyjaśnienie

Bardziej czytelny:

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

Zasadniczo dostaje nieskończoną listę liczb podzielnych przez jej cyfrową sumę i iloczyn, filtrując nieskończoną listę liczb całkowitych przez predykat. Następnie ten nelement jest po prostu wybierany z listy.

Julia, 81 bajtów

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)

Jest to anonimowa funkcja, która przyjmuje liczbę całkowitą i zwraca liczbę całkowitą. Aby to nazwać, nadaj mu nazwę. Podejście jest oczywiste: sprawdzaj każdą liczbę, aż napotkamy nwarunki sekwencji. allWyboru jest konieczne w celu zapewnienia, że nie dostać DivisionErrorod% kiedy iloczyn cyfr jest 0.

Nie golfowany:

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

Wypróbuj online! (obejmuje wszystkie przypadki testowe)

C89, 381 226 195 170 169 bajtów

1-indeksowane (takie same dokładne odpowiedzi jak w wyzwaniu).

Zakłada 4 bajty (32 bity)int (najnowocześniejsze architektury) .

Naprawdę wierzę, że to nie może być krótsze.

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

Funkcjonować int g (int) wycieka z pamięci i uzyskuje dostęp do niezainicjowanej pamięci raz na połączenie, ale nie powoduje awarii i zwraca właściwy numer.

Pełny program, który pobiera dane wejściowe ./prog $(seq 1 10)unarne (dla 10) z nie golfowym (trochę):

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

Stara odpowiedź:

C99, 381 bajtów

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

To może być bardziej golfa.

Pełny 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 bajtów

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

Niegolfowane i użytkowanie:

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 bajtów

Nowa wersja dzięki Flp.Tkc

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

Nowy kod, przypomniałem sobie sposób gry w golfa

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

Sam kod nie jest bardzo golfowy, bardziej przypomina golf brutalny

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) to funkcja, która zwraca True, jeśli x spełnia kryteria.

PHP, 96 bajtów

Trwa n jako argument wiersza poleceń.

Grał w golfa

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

Bez golfa

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 bajty

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

Iteracyjne rozwiązanie. Pobiera dane wejściowe $ni wchodzi w forpętlę, dopóki $nnie jest równa zero. Każdą iterację odejmujemy od $nwyniku instrukcji logicznej, podzielonej poniżej:

!(++$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

Zatem tylko wtedy, gdy $a%(sum)i oba$a%(product) są równe zeru, to dodanie również będzie równe zero, a zatem wartość logiczna nie będzie Prawda, a zatem zostanie zmniejszona.$n

Po wyjściu z pętli (tj. Trafieniu n-tego terminu), po prostu umieszczamy $aw potoku, a dane wyjściowe są niejawne.

Przykłady

Uwaga: to rzuca kilka o „usiłowanie dzielenia przez zero” błędy na stderr, który jest domyślnie ignorowany. Dodałem jawnie 2>$nulldo poniższego przykładu, aby wyczyścić dane wyjściowe. Jest również dość powolny, gdy dojdzie do około 30, i 50zajmuje około 45 sekund na moim komputerze.

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 bajtów

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