Pegue um número inteiro positivo X. Esse número faz parte da sequência na qual estamos interessados ​​se a soma de todos os dígitos de Xfor um divisor de X, e se o produto de todos os dígitos de Xfor um divisor de X.

Por exemplo, 135é esse número porque 1 + 3 + 5 = 9que divide 135 = 9 * 15e 1 * 3 * 5 = 15que também divide 135.

Esta é a sequência A038186 no OEIS.

Sua tarefa: dado um número inteiro N, imprima o Nnúmero inteiro positivo th com essas propriedades.

Entradas e saídas

• Os números podem ser 0-indexed ou 1-indexed; indique qual delas sua resposta usa.

• A entrada pode ser analisada STDIN, como argumento de função, ou qualquer coisa semelhante.

• A saída pode ser impressa STDOUT, retornada de uma função ou qualquer coisa semelhante.

Casos de teste

Os casos de teste abaixo são 1indexados.

Input        Output

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

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence.

05AB1E , 13 12 bytes

Agradecemos a Emigna por salvar um byte!

µNNSONSP‚ÖP½

Explicação:

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

Usa a codificação CP-1252 . Experimente online!

Pyke, 14 bytes (não competitivo) (1 indexado)

~1IY'sB]im%X)@

Experimente aqui!

Meu Deus, que muitas novidades.

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

Dos quais não competitivos

• uma correção de bug em Ique apenas verificaria se o primeiro item da pilha era verdadeiro
• digits - retorna uma lista de dígitos no número
• @ usado para obter o enésimo item de uma lista infinita

Dos quais estavam sendo usados ​​pela primeira vez:

• tudo acima
• listas infinitas

Remova os 2 últimos bytes para obter todos esses números.

C #, 118 bytes

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

Programa completo com funções não testadas e casos de teste:

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

Gelatina , 13 bytes

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

Baseado em 1.
TryItOnline!

Quão?

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 bytes (indexado 0)

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

Explicação:

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

Listas infinitas ftw!

Na verdade , 20 bytes

Implementação ingênua da definição de sequência. Sugestões de golfe são bem-vindas! Experimente 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.

Água-viva , 45 bytes

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

Experimente online!

Explicação

Este é de longe o programa mais elaborado (e também o mais longo) que escrevi na Jellyfish até agora. Não tenho idéia se vou conseguir resolver isso de uma maneira compreensível, mas acho que vou ter que tentar.

O Jellyfish fornece um operador de iteração bastante geral \, que ajuda muito a "encontrar o enésimo item ". Uma de suas semânticas é "iterar uma função em um valor até que uma função de teste separada forneça algo verdadeiro" (de fato, a função de teste recebe o elemento atual e o último, mas só faremos com que ela olhe para o elemento atual) . Podemos usar isso para implementar uma função "próximo número válido". Outra sobrecarga de \"itera uma função em um valor inicial N vezes". Podemos usar nossa função anterior e iterá-la em 0N vezes, onde N é a entrada. Tudo isso é configurado de forma bastante concisa com esta parte do código:

p
\Ai
\&
>     0

(As razões pelas quais 0a entrada real da função resultante é mais complicada e eu não irei abordá-las aqui.)

O problema de tudo isso é que não passaremos o valor atual para a função de teste manualmente. O \operador fará isso por nós. Então, agora construímos uma única função unária (por meio de composições, ganchos, garfos e curry) que pega um número e nos diz se é um número válido (isto é, um número dividido pela soma dos dígitos e pelo produto de dígitos). Isso é bastante trivial quando você não pode se referir ao argumento. Sempre. É essa beleza:

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

O (é um gancho unário , o que significa que ele chama a função abaixo ( f) em sua entrada (o valor atual x) e passa os dois para a função de teste à direita ( g), ou seja, calcula g(f(x), x).

No nosso caso, f(x)é outra função composta que obtém um par com o produto de dígitos e a soma de dígitos de x. Isso significa gque será uma função que possui todos os três valores para verificar se xé válido.

Começaremos analisando como fcalcula a soma e o dígito do produto. Isto é f:

 &~b
  10
 ( )/*
 /+

&também é composição (mas o contrário). ~está currying, portanto, 10~bfornece uma função que calcula os dígitos decimais de um número e, como estamos passando isso para &a direita, essa é a primeira coisa que acontecerá com a entrada x. O restante usa essa lista de dígitos para calcular sua soma e produto.

Para calcular uma soma, podemos dobrar a adição sobre ela, o que é /+. Da mesma forma, para calcular o produto, dobramos a multiplicação sobre ele /*. Para combinar esses dois resultados em um par, usamos um par de ganchos, (e ). A estrutura disso é:

()g
f

(Onde fe que gsão produto e soma, respectivamente.) Vamos tentar descobrir por que isso nos dá um par de f(x)e g(x). Observe que o gancho certo )tem apenas um argumento. Nesse caso, o outro argumento está implícito em ser o ;que agrupa seus argumentos em um par. Além disso, os ganchos também podem ser usados ​​como funções binárias (o que será o caso aqui), caso em que simplesmente aplicam a função interna apenas a um argumento. Então, )na verdade, uma única função gfornece uma função que calcula [x, g(y)]. Usando isso no gancho esquerdo, junto com f, obtemos [f(x), g(y)]. Isso, por sua vez, é usado em um contexto unário, o que significa que na verdade é chamado com x == ye, portanto, terminamos com [f(x), g(x)]o necessário. Ufa.

Isso deixa apenas uma coisa, que foi nossa função de teste anterior g. Lembre-se de que ele será chamado como g([p, s], x)onde xainda é o valor de entrada atual, pé seu produto de dígitos e ssua soma de dígitos. Isto é g:

  &]&|
  <*&d
    N

Para testar a divisibilidade, obviamente usaremos o módulo, que está |no Jellyfish. De maneira um tanto incomum, ele usa seu operando do lado direito e seu operando do lado esquerdo, o que significa que os argumentos gjá estão na ordem correta (funções aritméticas como essa encadeiam automaticamente as listas, portanto, ele calculará os dois módulos separados gratuitamente) . Nosso número é divisível pelo produto e pela soma, se o resultado for um par de zeros. Para verificar se é esse o caso, tratamos o par como uma lista de dígitos da base 2 ( d). O resultado disso é zero, somente quando os dois elementos do par são zero, portanto, podemos negar o resultado disso ( N) para obter um valor verdadeiro para se ambos os valores dividem a entrada. Note-se que |, deNsão simplesmente todos compostos em conjunto com um par de &s.

Infelizmente, essa não é a história completa. E se o produto com dígitos for zero? Divisão e módulo por zero retornam zero na água-viva. Embora isso possa parecer uma convenção um tanto estranha, na verdade acaba sendo útil (porque não precisamos verificar o zero antes de fazer o módulo). No entanto, também significa que podemos obter um falso positivo, se a soma dos dígitos dividir a entrada, mas o produto do dígito for zero (por exemplo, entrada 10).

Podemos corrigir isso multiplicando nosso resultado de divisibilidade pelo produto de dígito (portanto, se o produto de dígito for zero, ele também transformará nosso valor de verdade em zero). É mais simples multiplicar o resultado da divisibilidade pelo par de produto e soma e extrair o resultado do produto posteriormente.

Para multiplicar o resultado pelo par, precisamos voltar a um valor anterior (o par). Isso é feito com um garfo ( ]). Garfos são como ganchos com esteróides. Se você lhes der duas funções fe g, elas representam uma função binária que calcula f(a, g(a, b)). No nosso caso, aé o par produto / soma, bé o valor de entrada atual, gé o nosso teste de divisibilidade e fé a multiplicação. Então, tudo isso calcula [p, s] * ([p, s] % x == [0, 0]).

Tudo o que resta agora é extrair o primeiro valor disso, que é o valor final da função de teste usada no iterador. Isso é tão simples quanto compor ( &) o fork com a função head< , que retorna o primeiro valor de uma lista.

R, 132 115 bytes

Nova versão graças aos bons comentários do @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

Como R se comporta de maneira estranha com NAs, eu tive que adicionar a ifelse(is.na(...))parte inteira !
Ou usena.omit(...)

Braquilog , 22 bytes

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

Experimente online!

Explicação

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

Menos golfe

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

Pitão, 18 bytes

e.f!.xs%LZsM*FBsM`

Experimente online: Demonstração

Explicação:

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 bytes

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

Demo

Tende a ser lento para valores mais altos, então estou limitando-o a 20 aqui.

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 bytes

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

1 indexado.

Obrigado ao @Zgarb por salvar 13 bytes!

Agradecemos a @nimi por salvar um byte!

MATL , 21 bytes

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

Longo e ineficiente ...

Experimente online!

Como funciona

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

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

Isso ficou um pouco parecido com a resposta de @ Arnauld, mas a recursão é aparentemente 2 bytes mais curta. Funciona no Chrome, embora seja muito lento em entradas maiores que 30 ou mais (50 leva 6 segundos).

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 indexado, você precisa usar um interpretador Python com um limite de recursão bastante alto.

Maravilha, 33 bytes

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

Indexado a zero. Uso:

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

Explicação

Mais legível:

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

Basicamente, obtém uma lista infinita de números divisíveis por sua soma e produto digital, filtrando uma lista infinita de números inteiros por meio de um predicado. Em seguida, o nitem é simplesmente retirado da lista.

Julia, 81 bytes

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)

Esta é uma função anônima que aceita um número inteiro e retorna um número inteiro. Para chamá-lo, dê um nome. A abordagem é óbvia: verifique todos os números até encontrarmos os ntermos da sequência. A allverificação é necessária para garantir que não recebemos a DivisionErrorpartir de %quando o produto dos dígitos for 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

Experimente online! (inclui todos os casos de teste)

C89, 381 226 195 170 169 bytes

1 indexado (mesmas respostas exatas que no desafio).

Supõe 4 bytes (32 bits)int (arquiteturas mais modernas) .

Eu realmente acredito que isso não pode ser mais curto.

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

A função int g (int)vaza memória e acessa a memória não inicializada uma vez por chamada, mas não falha automaticamente e retorna o número certo.

Programa completo que recebe entrada em unário ( ./prog $(seq 1 10)por 10) com não-golfado (tipo):

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

Resposta antiga:

C99, 381 bytes

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

Provavelmente isso pode ser jogado mais.

Programa completo:

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

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 e uso:

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

Nova versão graças ao 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))

Novo código, lembrei-me de uma maneira de fazer o fatorial no golfe

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

O código em si não é muito parecido com o golfe, mais como o golfe de força bruta

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) é uma função que retorna True se x se encaixa nos critérios.

PHP, 96 bytes

Toma ncomo um argumento de linha de comando.

Golfe

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 bytes

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

Solução iterativa. Recebe entrada $ne entra em um forloop desde que $nnão seja zero. Cada iteração, subtraímos do $nresultado de uma instrução booleana, dividida abaixo:

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

Assim, apenas se $a%(sum)e $a%(product)são ambos iguais a zero será a adição também ser zero e, portanto, o booleana-não será verdadeira e, por conseguinte, $né decrementado.

Quando saímos do loop (ou seja, atingimos o enésimo termo), simplesmente colocamos $ano pipeline e a saída é implícita.

Exemplos

Nota: Isso lança um monte de erros "Tentativa de dividir por zero" para STDERR, que é ignorado por padrão. Eu adicionei explicitamente um 2>$nullao exemplo abaixo para limpar a saída. Também é muito lento uma vez que fica a cerca de 30mais ou menos, e 50leva cerca de 45 segundos em minha máquina.

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 bytes

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