Візьміть натуральне число X. Це число є частиною послідовності, яка нас цікавить, якщо сума всіх цифр X- це дільник X, і якщо добуток усіх цифр X- дільник X.

Наприклад, 135є таке число, тому 1 + 3 + 5 = 9що, яке розділяє, 135 = 9 * 15і 1 * 3 * 5 = 15яке також ділиться 135.

Це послідовність A038186 в OEIS.

Ваше завдання: задавши ціле число N, виведіть це Nдодатне ціле число з такими властивостями.

Входи та виходи

• Числа можуть бути 0-індексованими або 1-індексованими; вкажіть, будь ласка, який із ваших відповідей використовуєте.

• Вхід може сприйматись STDINяк аргумент функції або щось подібне.

• Вихід може бути надрукований STDOUT, повернутий з функції або щось подібне.

Тестові справи

Нижче наведені 1тестові приклади.

Input        Output

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

Оцінка балів

Це код-гольф , тому найкоротша відповідь у байтах виграє.

05AB1E , 13 12 байт

Дякуємо Еміньї за збереження байта!

µNNSONSP‚ÖP½

Пояснення:

µ          ½   # 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 . Спробуйте в Інтернеті!

Пайк, 14 байт (неконкурентоспроможний) (1-індексований)

~1IY'sB]im%X)@

Спробуйте тут!

Боже мій, що багато нового.

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

З яких є неконкурентоспроможними

• виправлення, у Iякому він би перевіряв лише, чи був перший елемент стека правдивим
• digits - повернути список цифр у цифрі
• @ використовується для отримання n-го пункту нескінченного списку

З них використовувались вперше:

• все вищеперераховане
• нескінченні списки

Видаліть останні 2 байти, щоб отримати всі ці числа.

C #, 118 байт

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

Повна програма з функцією безготівки та тестовими кейсами:

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

Желе , 13 байт

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

На основі 1.
СпробуйтеItOnline!

Як?

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 байти (0-індексований)

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

Пояснення:

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

Нескінченні списки ftw!

Власне , 20 байт

Наївна реалізація визначення послідовності. Пропозиції з гольфу вітаються! Спробуйте в Інтернеті!

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.

Медузи , 45 байт

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

Спробуйте в Інтернеті!

Пояснення

Це, на сьогоднішній день, найдосконаліша (а також найдовша) програма, яку я написав у «Медузи» поки що. Я не маю ідеї, чи зможу це зрушити в зрозумілій формі, але, мабуть, мені доведеться спробувати.

Медузи забезпечують досить загальний оператор ітерації \, який дуже допомагає "знайти Nth щось ". Однією з його семантики є "ітерація функції по значенню, поки окрема тестова функція не дає чогось правдоподібного" (насправді тестова функція отримує і поточний, і останній елемент, але ми лише змусимо її подивитися на поточний елемент) . Ми можемо використовувати це для реалізації функції "Наступне дійсне число". Ще одне перевантаження " \це повторити функцію на вихідне значення N разів". Ми можемо скористатися нашою попередньою функцією та повторити її в 0N разів, де N - вхід. Все це налаштовано досить стисло з цією частиною коду:

p
\Ai
\&
>     0

(Причини того 0, що фактичний вхід до отриманої функції закінчується, є дещо складними, і я тут не вдаваюся в них.)

Проблема у всьому цьому полягає в тому, що ми не передамо поточне значення тестовій функції вручну. \Оператор зробить це за нас. Отже, тепер ми побудуємо єдину функцію одинарної функції (за допомогою композицій, гачків, вилок і каррі), яка приймає число і повідомляє нам, чи дійсне це число (тобто таке, яке ділиться на його цифру на суму і цифру продукту). Це досить нетривіально, коли ви не можете посилатися на аргумент. Колись. Це ця краса:

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

Це (унарний гак , що означає, що він викликає функцію нижче ( f) на своєму вході (поточне значення x), а потім передає їх обоє тестовій функції праворуч ( g), тобто це обчислює g(f(x), x).

У нашому випадку - f(x)це ще одна складова функція, яка отримує пару з цифровим твором і сумою цифр x. Це означає g, що функція, яка має всі три значення, перевіряє, чи справді xвона.

Почнемо з розгляду того, як fобчислюється цифра суми та цифрного добутку. Це f:

 &~b
  10
 ( )/*
 /+

&також є композиція (але навпаки). ~currying, тому 10~bдає функцію, яка обчислює десяткові цифри числа, і оскільки ми передаємо &це праворуч, це перше, що станеться з введенням x. Решта використовує цей список цифр для обчислення їх суми та добутку.

Щоб обчислити суму, ми можемо скласти над нею додавання, що є /+. Аналогічно, для обчислення продукту ми складаємо множення на нього /*. Для об'єднання обох цих результатів у пару ми використовуємо пару гачків (та ). Структура цього:

()g
f

(Де fі gє добуток і сума відповідно.) Спробуємо розібратися, чому це дає нам пару f(x)і g(x). Зауважте, що правий гак )має лише один аргумент. У цьому випадку мається на увазі інший аргумент, ;який обертає свої аргументи в парі. Крім того, гачки також можуть бути використані як бінарні функції (що буде тут), і в цьому випадку вони просто застосовують внутрішню функцію лише до одного аргументу. Тож дійсно )по одній функції gдає функція, яка обчислює [x, g(y)]. Використовуючи це в лівому гачку, ми разом fотримуємо [f(x), g(y)]. Це, в свою чергу, використовується в одинарному контексті, а це означає, що він насправді викликається x == yі тому ми закінчуємо [f(x), g(x)]необхідне. Phew.

Це залишає лише одне, що було нашою попередньою функцією тестування g. Нагадаємо, що він буде називатися так, g([p, s], x)де xвсе ще знаходиться поточне вхідне значення, pє його цифровим добутком і sє його цифрова сума. Це g:

  &]&|
  <*&d
    N

Щоб перевірити подільність, ми, очевидно, будемо використовувати модуль, який є |у медуз. Дещо незвично він бере правого операнда по модулю його лівий операнд, а це означає, що аргументи gвже в правильному порядку (арифметичні функції, подібні до цього, автоматично передаються по списках, тому це обчислить дві окремі модулі безкоштовно) . Наше число ділиться як на добуток, так і на суму, якщо результат - пара нулів. Щоб перевірити, чи це так, ми розглядаємо пару як список базових 2 цифр ( d). Результат цього дорівнює нулю, лише тоді, коли обидва елементи пари дорівнюють нулю, тому ми можемо заперечити результат цього ( N), щоб отримати триєдне значення за тим, чи розділяють вхідні обидва значення. Слід зазначити , що |, dіNпросто всі складені разом з парою &s.

На жаль, це ще не повна історія. Що робити, якщо розрядний добуток дорівнює нулю? Ділення і модуль на нуль обидва повертають нуль у медуз. Хоча це може здатися дещо дивним умовою, воно насправді виявляється дещо корисним (адже нам не потрібно перевіряти нуль, перш ніж робити модуль). Однак це також означає, що ми можемо отримати помилковий позитивний результат, якщо цифра суми розділяє вхід, але цифровий добуток дорівнює нулю (наприклад, введення 10).

Ми можемо це виправити, помноживши результат ділення на цифровий добуток (так що, якщо цифровий добуток дорівнює нулю, він перетворить і наше нульове значення на нуль). Виявляється, простіше помножити результат поділу на пару продукту і суму, а потім отримати результат з продукту.

Щоб помножити результат на пару, нам якось потрібно повернутися на більш раннє значення (пара). Це робиться виделкою ( ]). Вилки як би гачки на стероїдах. Якщо ви дасте їм дві функції fі gвони являють собою бінарну функцію , яка обчислює f(a, g(a, b)). У нашому випадку a- це продукт / сума пари, bє поточним вхідним значенням, gє нашим тестом на роздільність і fє множенням. Отже, все це обчислюється [p, s] * ([p, s] % x == [0, 0]).

Все, що залишилося зараз, - це отримати перше значення цього, яке є кінцевим значенням тестової функції, що використовується в ітераторі. Це так само просто, як складати ( &) виделку з головною функцією <, яка повертає перше значення списку.

R, 132 115 байт

Нова версія завдяки @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

Безголовки:

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

Оскільки R поводиться странґлі з NAs, мені довелося додати всю ifelse(is.na(...))частину!
Або використовуватиna.omit(...)

Брахілог , 22 байти

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

Спробуйте в Інтернеті!

Пояснення

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

Менше гольфу

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

Піт, 18 байт

e.f!.xs%LZsM*FBsM`

Спробуйте в Інтернеті: Демонстрація

Пояснення:

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 байти

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

Демо

Для більш високих значень воно, як правило, повільно, тому я тут обмежую його 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 байт

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

1-індексований.

Дякуємо @Zgarb за збереження 13 байт!

Дякуємо @nimi за збереження байта!

MATL , 21 байт

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

Довго і неефективно ...

Спробуйте в Інтернеті!

Як це працює

`        % 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 байт

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

Це виявилося зовсім схожим на відповідь @ Арнаульда, але рекурсія, мабуть, на 2 байти коротша. Працює в Chrome, хоча це дуже повільно на входах, що перевищують 30 або більше (50 займає 6 секунд).

Пітон 2, 122 110 байт

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 індексовано, вам потрібно використовувати інтерпретатор Python із досить високою межею рекурсії.

Диво, 33 байти

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

Нульова індексація. Використання:

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

Пояснення

Більше читати:

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

В основному отримує нескінченний список чисел, розділених на його цифрову суму та добуток, фільтруючи нескінченний список цілих чисел через присудок. Потім цей nпункт просто вибирається зі списку.

Джулія, 81 байт

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)

Це анонімна функція, яка приймає ціле число і повертає ціле число. Щоб зателефонувати, дайте ім’я. Підхід очевидний: перевіряйте кожне число, поки ми не зустрінемося з nтермінами послідовності. allПеревірка необхідна , щоб гарантувати , що ми не отримуємо DivisionErrorвід %коли твір цифр 0.

Безголівки:

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

Спробуйте в Інтернеті! (включає всі тестові випадки)

C89, 381 226 195 170 169 байт

1-індексований (такі ж точні відповіді, як у виклику).

Припускає 4-байтовий (32 бітний)int (більшість сучасних архітектур) .

Я щиро вірю, що це не може бути коротшим.

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

Функція int g (int)протікає в пам'яті та отримує доступ до неініціалізованої пам'яті один раз на виклик, але не сегментується та повертає потрібний номер.

Повна програма, яка приймає дані в одинаковому ( ./prog $(seq 1 10)для 10) з ненуленими (ніби):

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

Стара відповідь:

C99, 381 байт

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

Це, ймовірно, може бути більше гольфу.

Повна програма:

#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 байт

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

Безголівки та використання:

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 байт

Нова версія завдяки 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))

Новий код, я згадав про гольф-спосіб зробити фактор

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

Сам код не дуже схожий на гольф, більше нагадує грубу силу гольфу

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) - це функція, яка повертає True, якщо x відповідає критеріям.

PHP, 96 байт

Бере n аргументом командного рядка.

Гольф

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

Безумовно

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 байти

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

Ітеративне рішення. Займає вхід $nі вводить forцикл до тих пір, $nпоки не дорівнює нулю. Кожну ітерацію ми віднімаємо від $nрезультату булевого твердження, розбитого нижче:

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

Таким чином, тільки якщо $a%(sum)і $a%(product)є одночасно дорівнюють нулю буде додавання також може дорівнювати нулю, і , отже , булева-ні буде істинним і , отже , $nзменшується.

Як тільки ми виходимо з циклу (тобто натискаємо на n- ту доданок), ми просто розміщуємо $aна конвеєрі, і вихід неявний.

Приклади

Примітка. Це кидає купу помилок "Спроба розділити на нуль" STDERR, яка за замовчуванням ігнорується. Я чітко додав a 2>$nullдо прикладу нижче, щоб очистити вихід. Це також досить повільно, коли він добирається до близько 30того, і 50займає на моїй машині близько 45 секунд.

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

БАШ, 125 байт

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