Ambil bilangan bulat positif X. Nomor ini adalah bagian dari urutan yang kami minati jika jumlah semua digit Xadalah pembagi X, dan jika produk dari semua digit Xadalah pembagi X.

Sebagai contoh, 135adalah angka seperti itu karena 1 + 3 + 5 = 9yang membelah 135 = 9 * 15dan 1 * 3 * 5 = 15yang juga membelah 135.

Ini adalah urutan A038186 dalam OEIS.

Tugas Anda: diberi bilangan bulat N, output Nbilangan bulat positif th dengan properti tersebut.

Masukan dan keluaran

• Angka bisa 0-indeks atau 1-indeks; tolong tunjukkan jawaban yang Anda gunakan.

• Input dapat diambil melalui STDIN, sebagai argumen fungsi, atau yang serupa.

• Output dapat dicetak ke STDOUT, dikembalikan dari fungsi, atau yang serupa.

Uji kasus

Kasus uji di bawah ini adalah 1-indeks.

Input        Output

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

Mencetak gol

Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.

05AB1E , 13 12 byte

Terima kasih kepada Emigna karena telah menghemat satu byte!

µNNSONSP‚ÖP½

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online!

Pyke, 14 byte (tidak kompetitif) (1-diindeks)

~1IY'sB]im%X)@

Coba di sini!

Ya Tuhan apa yang banyak fitur baru.

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

Di antaranya tidak kompetitif

• perbaikan bug di Imana ia hanya akan memeriksa apakah item pertama pada stack itu benar
• digits - mengembalikan daftar angka dalam angka
• @ digunakan untuk mendapatkan item ke-n dari daftar yang tak terbatas

Dari yang digunakan untuk pertama kalinya:

• semua yang di atas
• daftar tak terbatas

Hapus 2 byte terakhir untuk mendapatkan semua angka-angka ini.

C #, 118 byte

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

Program lengkap dengan fungsi dan uji kasus yang tidak dikoleksi:

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

Jelly , 13 byte

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

Berbasis 1.
TryItOnline!

Bagaimana?

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 byte (0-diindeks)

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

Penjelasan:

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

Infinite list ftw!

Sebenarnya , 20 byte

Implementasi naif definisi urutan. Selamat datang saran bermain golf! Cobalah online!

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

Tidak melakukanolf

         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.

Ubur-ubur , 45 byte

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

Cobalah online!

Penjelasan

Sejauh ini, ini adalah program yang paling rumit (dan juga yang terpanjang) yang saya tulis di Jellyfish sejauh ini. Saya tidak tahu apakah saya akan dapat memecah ini dengan cara yang dimengerti, tapi saya rasa saya harus mencoba.

Ubur-ubur menyediakan operator iterasi yang cukup umum \,, yang banyak membantu dengan "menemukan sesuatu yang ke- N ". Salah satu semantiknya adalah "beralih fungsi pada nilai sampai fungsi tes terpisah memberikan sesuatu yang benar" (pada kenyataannya, fungsi tes menerima elemen saat ini dan yang terakhir, tetapi kami hanya akan membuatnya melihat elemen saat ini) . Kita dapat menggunakan ini untuk mengimplementasikan fungsi "angka valid berikutnya". Kelebihan lainnya \adalah "beralih fungsi pada nilai awal N kali". Kita dapat menggunakan fungsi sebelumnya dan mengulanginya pada 0N kali, di mana N adalah input. Semua itu diatur cukup ringkas dengan bagian kode ini:

p
\Ai
\&
>     0

(Alasan mengapa 0, input aktual ke fungsi yang dihasilkan, ada di sana agak rumit dan saya tidak akan membahasnya di sini.)

Masalah dengan semua ini adalah, bahwa kita tidak akan meneruskan nilai saat ini ke fungsi tes secara manual. The \Operator akan melakukan ini untuk kita. Jadi kita sekarang telah membangun fungsi unary tunggal (melalui komposisi, kait, garpu dan currying) yang mengambil angka dan memberi tahu kita apakah itu nomor yang valid (yaitu yang dibagi dengan jumlah digit dan produk digit). Ini cukup non-sepele ketika Anda tidak bisa merujuk ke argumen. Pernah. Ini keindahan ini:

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

Ini (adalah pengait unary , yang artinya memanggil fungsi di bawah ( f) pada inputnya (nilai saat ini x), dan kemudian meneruskan keduanya ke fungsi pengujian di sebelah kanan (g ), yang dihitungnya g(f(x), x).

Dalam kasus kami, f(x)adalah fungsi komposit lain yang memperoleh pasangan dengan produk digit dan jumlah digit x. Itu berarti gakan menjadi fungsi yang memiliki ketiga nilai untuk memeriksa apakahx valid.

Kami akan mulai dengan melihat bagaimana fmenghitung jumlah digit dan produk digit. Ini adalah f:

 &~b
  10
 ( )/*
 /+

&juga komposisi (tetapi sebaliknya). ~adalah currying sehingga 10~bmemberikan fungsi yang menghitung angka desimal angka, dan karena kita meneruskannya ke& dari kanan, itulah hal pertama yang akan terjadi pada input x. Sisanya menggunakan daftar angka ini untuk menghitung jumlah dan produk mereka.

Untuk menghitung jumlah, kita dapat melipat tambahan di atasnya, yaitu /+. Demikian juga, untuk menghitung produk kami melipat gandakan dengan itu /*. Untuk menggabungkan kedua hasil ini menjadi sepasang, kami menggunakan sepasang kait, (dan ). Struktur ini adalah:

()g
f

(Dimana fdan mana gadalah produk dan jumlah, masing-masing.) Mari kita coba mencari tahu mengapa ini memberi kita sepasang f(x)dan g(x). Perhatikan bahwa hook kanan )hanya memiliki satu argumen. Dalam hal ini, argumen lain disiratkan sebagai ;argumen yang membungkus pasangannya. Selanjutnya, kait juga dapat digunakan sebagai fungsi biner (yang akan menjadi kasus di sini) dalam hal ini mereka hanya menerapkan fungsi dalam hanya untuk satu argumen. Jadi sebenarnya )pada satu fungsi gmemberikan fungsi yang menghitung [x, g(y)]. Menggunakan ini di hook kiri, bersama dengan f, kita dapatkan [f(x), g(y)]. Ini, pada gilirannya digunakan dalam konteks unary, yang berarti bahwa itu sebenarnya dipanggil dengan x == ydan akhirnya kita sesuai dengan yang [f(x), g(x)]diperlukan. Fiuh.

Hanya menyisakan satu hal, yang merupakan fungsi pengujian kami sebelumnya g. Ingatlah bahwa itu akan disebut sebagai di g([p, s], x)mana xmasih nilai input saat ini, padalah produk digitnya dan sjumlah digitnya. Ini adalah g:

  &]&|
  <*&d
    N

Untuk menguji kemampuan membagi, kami jelas akan menggunakan modulo, yang ada |di Jellyfish. Agak luar biasa, ia mengambil operan kanan modulo operannya kiri, yang berarti bahwa argumen gsudah dalam urutan yang benar (fungsi aritmatika seperti ini secara otomatis memasukkan daftar, jadi ini akan menghitung dua moduli terpisah secara gratis) . Nomor kami dapat dibagi oleh produk dan jumlah, jika hasilnya adalah nol. Untuk memeriksa apakah itu masalahnya, kami memperlakukan pasangan sebagai daftar digit basis-2 ( d). Hasil dari ini adalah nol, hanya ketika kedua elemen dari pasangan adalah nol, sehingga kita dapat meniadakan hasil dari ini ( N) untuk mendapatkan nilai kebenaran apakah kedua nilai membagi input. Catat itu |, ddanN semua disusun dengan sepasang &s.

Sayangnya, itu bukan cerita lengkapnya. Bagaimana jika produk digitnya nol? Pembagian dan modulo dengan nol keduanya menghasilkan nol di Jellyfish. Walaupun ini mungkin tampak seperti konvensi yang agak aneh, sebenarnya ternyata agak berguna (karena kita tidak perlu memeriksa nol sebelum melakukan modulo). Namun itu juga berarti kita bisa mendapatkan false positive, jika jumlah digit memang membagi input, tetapi produk digit adalah nol (mis. Input 10).

Kami dapat memperbaikinya dengan mengalikan hasil pembagian kami dengan produk digit (jadi jika produk digit adalah nol, itu akan mengubah nilai kebenaran kami menjadi nol juga). Ternyata lebih mudah untuk melipatgandakan hasil pembagian dengan pasangan produk dan jumlah, dan mengekstrak hasil dari produk sesudahnya.

Untuk mengalikan hasil dengan pasangan, kita perlu mengembalikan nilai sebelumnya (pasangan). Ini dilakukan dengan garpu ( ]). Garpu agak seperti kait pada steroid. Jika Anda memberi mereka dua fungsi fdan g, mereka mewakili fungsi biner yang menghitung f(a, g(a, b)). Dalam kasus kami, aadalah pasangan produk / jumlah, badalah nilai input saat ini, gadalah uji keterbagian kami, dan fmerupakan perkalian. Jadi semua ini menghitung [p, s] * ([p, s] % x == [0, 0]).

Yang tersisa sekarang adalah mengekstraksi nilai pertama ini, yang merupakan nilai akhir dari fungsi tes yang digunakan dalam iterator. Ini sesederhana membuat ( &) fork dengan fungsi kepala< , yang mengembalikan nilai pertama dari daftar.

R, 132 115 byte

Versi baru berkat @Billywob komentar yang bagus!

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

Tidak Terkumpul:

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

Karena R berperilaku strangley dengan NAs, saya harus menambahkan seluruh ifelse(is.na(...))bagian!
Atau gunakanna.omit(...)

Brachylog , 22 byte

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

Cobalah online!

Penjelasan

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

Kurang golf

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 byte

e.f!.xs%LZsM*FBsM`

Cobalah online: Demonstrasi

Penjelasan:

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 byte

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

Demo

Ini cenderung lambat untuk nilai yang lebih tinggi, jadi saya membatasi sampai 20 di sini.

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 byte

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

1-diindeks.

Terima kasih kepada @Zgarb karena telah menghemat 13 byte!

Terima kasih kepada @nimi karena telah menghemat satu byte!

MATL , 21 byte

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

Panjang dan tidak efisien ...

Cobalah online!

Bagaimana itu bekerja

`        % 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 byte

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

Ini ternyata sedikit seperti jawaban @ Arnauld, tetapi rekursi tampaknya 2 byte lebih pendek. Bekerja di Chrome, meskipun sangat lambat pada input yang lebih dari 30 atau lebih (50 membutuhkan waktu 6 detik).

Python 2, 122 110 Bytes

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 diindeks, Anda perlu menggunakan juru bahasa Python dengan batas rekursi yang cukup tinggi.

Bertanya-tanya, 33 byte

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

Diindeks nol. Pemakaian:

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

Penjelasan

Lebih mudah dibaca:

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

Pada dasarnya mendapatkan daftar nomor tak terbatas yang dapat dibagi dengan jumlah digital dan produknya dengan memfilter daftar nomor tak terbatas seluruh melalui predikat. Maka nitem ke-10 hanya diambil dari daftar.

Julia, 81 byte

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)

Ini adalah fungsi anonim yang menerima integer dan mengembalikan integer. Untuk menyebutnya, berikan nama. Pendekatannya adalah yang jelas: periksa setiap angka sampai kita menemukan nketentuan urutannya. The allcek diperlukan untuk memastikan kita tidak mendapatkan DivisionErrordari% ketika produk dari angka adalah 0.

Tidak Disatukan:

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

Cobalah online! (termasuk semua kasus uji)

C89, 381 226 195 170 169 byte

1-diindeks (jawaban persis sama seperti pada tantangan).

Diasumsikan 4-byte (32 bit)int (kebanyakan arsitektur modern) .

Saya benar-benar percaya ini tidak bisa lebih pendek.

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

Fungsi int g (int) bocor memori dan mengakses memori yang tidak diinisialisasi satu kali per panggilan tetapi tidak membuat kesalahan dan mengembalikan nomor yang benar.

Program lengkap yang mengambil input unary ( ./prog $(seq 1 10)untuk 10) dengan ungolfed (agak):

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

Jawaban lama:

C99, 381 byte

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

Ini mungkin bisa lebih banyak golf.

Program lengkap:

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

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

Tidak digabungkan dan digunakan:

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 Bytes

Versi baru berkat 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))

Kode baru, saya ingat cara bermain golf untuk faktorial

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

Kode itu sendiri tidak seperti golf, lebih seperti golf brute force

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) adalah fungsi yang mengembalikan True jika x cocok dengan kriteria.

PHP, 96 byte

Dibutuhkan n sebagai argumen baris perintah.

Golf

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

Tidak disatukan

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 byte

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

Solusi berulang. Mengambil input $ndan memasukkan satu forloop selama $nbukan nol. Setiap iterasi, kami kurangi dari $nhasil pernyataan Boolean, dijelaskan di bawah ini:

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

Jadi, hanya jika $a%(sum)dan $a%(product)yang kedua sama dengan nol akan Selain juga menjadi nol, dan dengan demikian Boolean-tidak akan menjadi Benar dan karena itu $ndecremented.

Setelah kami keluar dari loop (yaitu, kami menekan n istilah ), kita cukup menempatkan $apada pipeline, dan output tersirat.

Contohnya

Catatan: Ini melempar banyak kesalahan "Mencoba membagi dengan nol" ke STDERR, yang diabaikan secara default. Saya telah secara eksplisit menambahkan 2>$nullcontoh di bawah ini untuk membersihkan output. Ini juga sangat lambat begitu mencapai sekitar 30atau lebih, dan 50membutuhkan sekitar 45 detik pada mesin saya.

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 byte

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