Toma un número entero positivo X. Este número es parte de la secuencia que nos interesa si la suma de todos los dígitos de Xes un divisor de X, y si el producto de todos los dígitos de Xes un divisor de X.

Por ejemplo, 135es un número así porque 1 + 3 + 5 = 9cuál divide 135 = 9 * 15y 1 * 3 * 5 = 15cuál también divide 135.

Esta es la secuencia A038186 en el OEIS.

Su tarea: dado un número entero N, genera el Nnúmero entero positivo th con tales propiedades.

Entradas y salidas

• Los números pueden estar 0indexados o 1indexados; indique cuál usa su respuesta.

• La entrada puede tomarse STDIN, como un argumento de función, o algo similar.

• La salida puede imprimirse STDOUT, devolverse desde una función o algo similar.

Casos de prueba

Los siguientes casos de prueba están 1indexados.

Input        Output

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

Tanteo

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

05AB1E , 13 12 bytes

¡Gracias a Emigna por guardar un byte!

µNNSONSP‚ÖP½

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Pyke, 14 bytes (no competitivo) (1 indexado)

~1IY'sB]im%X)@

Pruébalo aquí!

Dios mío, muchas características nuevas.

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

De los cuales no son competitivos

• una corrección de errores en la Ique solo verificaría si el primer elemento de la pila era verdadero
• digits - devolver una lista de dígitos en el número
• @ se usa para obtener el enésimo elemento de una lista infinita

De los cuales fueron utilizados por primera vez:

• Todas las anteriores
• listas infinitas

Elimine los últimos 2 bytes para obtener todos estos 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 con función no protegida y casos de prueba:

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

Jalea , 13 bytes

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

Basado en 1.
TryItOnline!

¿Cómo?

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..*)[$_]}

Explicación:

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

Infinitas listas ftw!

En realidad , 20 bytes

Implementación ingenua de la definición de secuencia. Sugerencias de golf bienvenidas! Pruébalo en línea!

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.

Medusa , 45 bytes

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

Pruébalo en línea!

Explicación

Este es, con mucho, el programa más elaborado (y también el más largo) que he escrito en Jellyfish hasta ahora. No tengo idea de si podré analizar esto de una manera comprensible, pero supongo que tendré que intentarlo.

Jellyfish proporciona un operador de iteración bastante general \, que ayuda mucho a "encontrar el enésimo algo ". Una de sus semánticas es "iterar una función en un valor hasta que una función de prueba separada proporcione algo verdadero" (de hecho, la función de prueba recibe tanto el elemento actual como el último, pero solo haremos que mire el elemento actual) . Podemos usar esto para implementar una función de "siguiente número válido". Otra sobrecarga de \es "iterar una función en un valor inicial N veces". Podemos usar nuestra función anterior e iterarla en 0N veces, donde N es la entrada. Todo eso está configurado de manera bastante concisa con esta parte del código:

p
\Ai
\&
>     0

(Las razones por las cuales 0la entrada real a la función resultante está allí son un poco complicadas y no las abordaré aquí).

El problema con todo esto es que no pasaremos el valor actual a la función de prueba manualmente. El \operador hará esto por nosotros. Así que ahora hemos construido una única función unaria (a través de composiciones, ganchos, tenedores y curry) que toma un número y nos dice si es un número válido (es decir, uno que se divide por su suma de dígitos y producto de dígitos). Esto es bastante trivial cuando no puede referirse al argumento. Siempre. Es esta belleza:

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

El (es un unario gancho , lo que significa que llama a la función de abajo ( f) en su entrada (el valor actual x) y, a continuación, pasa a ambos a la función de prueba a la derecha ( g), que es lo calcula g(f(x), x).

En nuestro caso, f(x)es otra función compuesta que obtiene un par con el producto de dígitos y la suma de dígitos de x. Eso significa gque será una función que tiene los tres valores para verificar si xes válida.

Comenzaremos observando cómo fcalcula la suma de dígitos y el producto de dígitos. Esto es f:

 &~b
  10
 ( )/*
 /+

&también es composición (pero al revés). ~es curry, así que 10~bda una función que calcula los dígitos decimales de un número, y dado que lo estamos pasando &desde la derecha, eso es lo primero que sucederá con la entrada x. El resto usa esta lista de dígitos para calcular su suma y producto.

Para calcular una suma, podemos doblar la suma sobre ella, que es /+. Del mismo modo, para calcular el producto doblamos la multiplicación sobre él /*. Para combinar ambos resultados en un par, utilizamos un par de ganchos (y ). La estructura de esto es:

()g
f

(Donde fy gson producto y suma, respectivamente.) Tratemos de descubrir por qué esto nos da un par de f(x)y g(x). Tenga en cuenta que el gancho derecho )solo tiene un argumento. En este caso, se supone que el otro argumento es el ;que envuelve sus argumentos en un par. Además, los ganchos también se pueden usar como funciones binarias (que será el caso aquí) en cuyo caso simplemente aplican la función interna solo a un argumento. Entonces, realmente )en una sola función gda una función que computa [x, g(y)]. Usando esto en un gancho izquierdo, junto con f, obtenemos [f(x), g(y)]. Esto, a su vez, se usa en un contexto unario, lo que significa que en realidad se llama con x == yy así terminamos [f(x), g(x)]según sea necesario. Uf.

Eso deja solo una cosa, que era nuestra función de prueba anterior g. Recuerde que se llamará como g([p, s], x)donde xsigue siendo el valor de entrada actual, pes su producto de dígitos y ses su suma de dígitos. Esto es g:

  &]&|
  <*&d
    N

Para probar la divisibilidad, obviamente usaremos el módulo, que está |en Jellyfish. De manera algo inusual, toma su módulo de operando de la derecha a su operando de la izquierda, lo que significa que los argumentos gya están en el orden correcto (las funciones aritméticas como esta se enhebran automáticamente en las listas, por lo que esto calculará los dos módulos separados de forma gratuita) . Nuestro número es divisible tanto por el producto como por la suma, si el resultado es un par de ceros. Para verificar si ese es el caso, tratamos el par como una lista de dígitos de base-2 ( d). El resultado de esto es cero, solo cuando ambos elementos del par son cero, por lo que podemos negar el resultado de this ( N) para obtener un valor verdadero de si ambos valores dividen la entrada. Tenga en cuenta que |, dyNsimplemente están todos compuestos junto con un par de &s.

Desafortunadamente, esa no es la historia completa. ¿Qué pasa si el producto de dígitos es cero? La división y el módulo por cero devuelven cero en Jellyfish. Si bien esto puede parecer una convención un tanto extraña, en realidad resulta ser algo útil (porque no necesitamos verificar cero antes de hacer el módulo). Sin embargo, también significa que podemos obtener un falso positivo, si la suma de dígitos divide la entrada, pero el producto de dígitos es cero (por ejemplo, entrada 10).

Podemos solucionar esto multiplicando nuestro resultado de divisibilidad por el producto del dígito (por lo tanto, si el producto del dígito es cero, también convertirá nuestro valor verdadero en cero). Resulta más simple multiplicar el resultado de divisibilidad con el par de producto y suma, y ​​extraer el resultado del producto después.

Para multiplicar el resultado con el par, necesitamos volver a un valor anterior (el par). Esto se hace con un tenedor ( ]). Los tenedores son como ganchos de esteroides. Si les da dos funciones fy g, representan una función binaria que computa f(a, g(a, b)). En nuestro caso, aes el par producto / suma, bes el valor de entrada actual, ges nuestra prueba de divisibilidad y fes la multiplicación. Entonces todo esto computa [p, s] * ([p, s] % x == [0, 0]).

Todo lo que queda ahora es extraer el primer valor de esto, que es el valor final de la función de prueba utilizada en el iterador. Esto es tan simple como componer ( &) la bifurcación con la función head< , que devuelve el primer valor de una lista.

R, 132115 bytes

Nueva versión gracias a los bonitos comentarios de @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

Sin golf:

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 comportó estrangulado con NAs, ¡tuve que agregar toda la ifelse(is.na(...))parte!
O usarna.omit(...)

Brachylog , 22 bytes

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

Pruébalo en línea!

Explicación

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

e.f!.xs%LZsM*FBsM`

Pruébelo en línea: demostración

Explicación:

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

Manifestación

Tiende a ser lento para valores más altos, así que lo estoy limitando a 20 aquí.

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.

¡Gracias a @Zgarb por guardar 13 bytes!

¡Gracias a @nimi por guardar un byte!

MATL , 21 bytes

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

Largo e ineficiente ...

Pruébalo en línea!

Cómo 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

Esto resultó bastante parecido a la respuesta de @ Arnauld, pero la recursión es aparentemente 2 bytes más corta. Funciona en Chrome, aunque es muy lento en entradas de más de 30 (50 tarda 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, debe usar un intérprete de Python con un límite de recursión bastante alto.

Maravilla, 33 bytes

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

Indexado a cero. Uso:

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

Explicación

Más legible:

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

Básicamente obtiene una lista infinita de números divisibles por su suma digital y producto al filtrar una lista infinita de números enteros a través de un predicado. Luego, el nelemento th simplemente se selecciona de la 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 es una función anónima que acepta un entero y devuelve un entero. Para llamarlo, dale un nombre. El enfoque es obvio: verifique cada número hasta que hayamos encontrado los ntérminos de la secuencia. La allverificación es necesaria para asegurar que no obtenemos una DivisionErrorde% cuando el producto de los dígitos es 0.

Sin golf:

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

Pruébalo en línea! (incluye todos los casos de prueba)

C89, 381 226 195 170 169 bytes

1 indexado (las mismas respuestas exactas que en el desafío).

Asume 4 bytes (32 bits)int (arquitecturas más modernas) .

Realmente creo que esto no puede ser más corto.

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

Función int g (int) pierde memoria y accede a la memoria no inicializada una vez por llamada, pero no falla por defecto y devuelve el número correcto.

Programa completo que toma la entrada en unario ( ./prog $(seq 1 10)para 10) con sin golf (un poco):

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

Vieja respuesta:

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

Esto probablemente se puede jugar más al golf.

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

Sin golf y 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

Nueva versión gracias a 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))

Nuevo código, recordé una forma de golf para hacer el factorial

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

El código en sí no es muy parecido al golf, más bien al campo de fuerza 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) es una función que devuelve True si x cumple los criterios.

PHP, 96 bytes

Toma ncomo argumento de línea de comando.

Golfed

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

Sin golf

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

Solución iterativa. Toma entrada $ny entra en un forbucle siempre que $nno sea cero. En cada iteración, restamos del $nresultado de una declaración booleana, que se desglosa a continuació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

Por lo tanto, sólo si $a%(sum)y $a%(product)son ambos igual a cero será la adición también ser cero, y por lo tanto el operador booleano-no será verdad y por lo tanto $nse decrementa.

Una vez que salimos del ciclo (es decir, tocamos el enésimo término), simplemente colocamos$a en la tubería y la salida es implícita.

Ejemplos

Nota: Esto arroja un montón de errores "Intento de dividir por cero" a STDERR, que se ignora por defecto. He agregado explícitamente 2>$nulla al ejemplo a continuación para limpiar la salida. También es bastante lento una vez que llega aproximadamente 30, y 50toma alrededor de 45 segundos en mi 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