Возьмите натуральное число 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 байт

Спасибо Emigna за сохранение байта!

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

Полная программа с функцией ungolfed и контрольными примерами:

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 на основе.
TryItOnline!

Как?

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
 ( )/+
 /*

Попробуйте онлайн!

объяснение

Это, безусловно, самая сложная (и самая длинная) программа, которую я когда-либо писал на «Медузах». Я понятия не имею, смогу ли я разобрать это понятным образом, но, думаю, мне придется попробовать.

Jellyfish предоставляет довольно общий оператор итерации \, который очень помогает в «поиске чего-то Nth ». Одна из его семантик - «итерация функции по значению, пока отдельная тестовая функция не даст что-то правдивое» (на самом деле тестовая функция получает как текущий, так и последний элемент, но мы только заставим его взглянуть на текущий элемент) , Мы можем использовать это для реализации функции «следующий действительный номер». Другая перегрузка \- это «перебрать функцию по начальному значению N раз». Мы можем использовать нашу предыдущую функцию и повторять ее 0N раз, где N - это ввод. Все это настроено довольно кратко с этой частью кода:

p
\Ai
\&
>     0

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

Проблема со всем этим в том, что мы не будем передавать текущее значение в тестовую функцию вручную. \Оператор сделает это за нас. Итак, теперь мы должны сконструировать единственную унарную функцию (с помощью композиций, хуков, вилок и карри), которая принимает число и сообщает нам, является ли оно действительным числом (т. Е. Делением на сумму, состоящую из цифр и цифр). Это довольно нетривиально, когда вы не можете ссылаться на аргумент. Когда-либо. Вот эта красота

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

Это (унарный хук , который означает, что он вызывает функцию ниже ( f) на своем входе (текущее значение x), а затем передает их оба в тестовую функцию right ( g), то есть вычисляет g(f(x), x).

В нашем случае f(x)это еще одна составная функция, которая получает пару с цифрой произведения и цифрой суммы x. Это означает g, что функция будет иметь все три значения, чтобы проверить, xявляется ли она действительной.

Мы начнем с рассмотрения того, как fвычисляется сумма и цифра произведения. Это f:

 &~b
  10
 ( )/*
 /+

&тоже композиция (но наоборот). ~каррирует, поэтому 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)]требованиями. Уф.

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

  &]&|
  <*&d
    N

Для проверки делимости мы, очевидно, будем использовать модуль по модулю | в Jellyfish. Несколько необычно, что он берет свой правый операнд по модулю своего левого операнда, что означает, что аргументы gуже находятся в правильном порядке (такие арифметические функции, как эта, автоматически перебирают списки, так что это вычислит два отдельных модуля бесплатно) , Наше число делится как на произведение, так и на сумму, если в результате получается пара нулей. Чтобы проверить, так ли это, мы рассматриваем пару как список цифр base-2 ( d). Результат этого равен нулю, только когда оба элемента пары равны нулю, поэтому мы можем отменить результат этого ( N), чтобы получить истинное значение для того, разделяют ли оба значения входные данные. Следует отметить , что |, dиNпросто все составлены вместе с парой &с.

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

Мы можем исправить это, умножив наш результат делимости на произведение цифр (поэтому, если произведение цифр равно нулю, оно также превратит наше истинное значение в ноль). Оказывается, проще умножить результат делимости на пару продукта и суммы, а затем извлечь результат из продукта.

Чтобы умножить результат на пару, нам нужно вернуться к более раннему значению (паре). Это делается с помощью fork ( ]). Вилы как крючки на стероидах. Если вы дадите им две функции fи g, они представляют двоичную функцию, которая вычисляет f(a, g(a, b)). В нашем случае aэто пара продукт / сумма, bтекущее входное значение, gнаш тест делимости и fумножение. Так что все это вычисляется [p, s] * ([p, s] % x == [0, 0]).

Осталось только извлечь первое значение этого, которое является окончательным значением тестовой функции, используемой в итераторе. Это так же просто, как composing ( &) форк с функцией head< , которая возвращает первое значение списка.

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

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

Поскольку 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
}  

Pyth, 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

Это оказалось немного похоже на ответ @ Arnauld, но рекурсия, видимо, на 2 байта короче. Работает в Chrome, хотя он очень медленный на входах больше 30 или около того (50 занимает 6 секунд).

Python 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

Zero-индексироваться. Использование:

(@:^#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.

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

Попробуйте онлайн! (включает все тестовые случаи)

С89, 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;}

Ungolfed и использование:

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 в качестве аргумента командной строки.

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

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, которая по умолчанию игнорируется. Я явно добавил 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

BASH, 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