양의 정수를 사용하십시오 X. 이 숫자는 모든 자릿수의 합이 X제수 X이고 모든 자릿수의 곱이 제수 인 경우에 관심이있는 시퀀스의 일부 X입니다 X.

예를 들어, 135같은 번호 때문에 1 + 3 + 5 = 9어떤 분할 135 = 9 * 15하고 1 * 3 * 5 = 15있는 분할도 135.

OEIS의 시퀀스 A038186 입니다.

당신의 작업 : integer가 주어지면 그러한 속성을 가진 양의 정수를 N출력하십시오 N.

입력 및 출력

• 숫자는 0색인화되거나 1색인화 될 수 있습니다 . 어떤 답변을 사용하는지 알려주십시오.

• 입력은 STDIN함수 인수 또는 이와 유사한 것으로 통해 수행 될 수 있습니다 .

• 출력은로 인쇄 STDOUT되거나 함수에서 반환되거나 이와 유사한 것으로 표시 될 수 있습니다 .

테스트 사례

아래의 테스트 사례는 1-indexed입니다.

Input        Output

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

채점

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

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

언 골핑

         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), 및 그 오른쪽 (상기 테스트 기능에 모두 전달 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)]되어 필요에 따라 끝납니다 . 휴

그것은 우리의 초기 테스트 기능인 한 가지만 남습니다 g. 이를이라한다 리콜 g([p, s], x)여기서 x여전히 현재의 입력 값은 p그 자리 제품 및 s그 자리 합이다. 이것은 g:

  &]&|
  <*&d
    N

분할 성을 테스트하기 위해 |Jellyfish에 있는 모듈로를 사용 합니다. 다소 특이하게, 그것은 오른쪽 피연산자 모듈로 왼쪽 피연산자를 취합니다. 즉, 인수가 g올바른 순서로 이미 있음을 의미합니다 (이와 같은 산술 함수는 목록을 자동으로 스레드하므로 두 개의 개별 모듈러스를 무료로 계산합니다) . 결과가 0의 쌍이면 우리의 숫자는 곱과 합으로 나눌 수 있습니다. 이러한 경우인지 확인하기 위해 쌍을 기본 2 자리 ( d) 목록으로 취급합니다 . 쌍의 두 요소가 모두 0 인 경우에만이 결과가 0이므로 N두 값이 입력을 나누는 지 여부에 대한 정확한 값을 얻기 위해이 결과를 무시할 수 있습니다. 그 주 |, d및N단순히 모두 &s 쌍으로 구성됩니다 .

불행히도, 그것은 전체 이야기가 아닙니다. 숫자 곱이 0이면 어떻게 되나요? 0으로 나누기와 모듈로는 해파리에서 0을 반환합니다. 이것은 다소 이상한 규칙처럼 보일지 모르지만 실제로는 다소 유용합니다 (모듈로를 수행하기 전에 0을 확인할 필요가 없기 때문에). 그러나 또한 숫자 합이 입력을 나누지 만 숫자 곱이 0이면 (예 : input 10) 오 탐지를 얻을 수 있음을 의미 합니다.

우리는이 분산 결과에 숫자 곱을 곱하여이 문제를 해결할 수 있습니다 (따라서 숫자 곱이 0이면 진솔한 값도 0이됩니다). 나누기 결과에 곱과 합을 곱하고 나중에 그 결과를 추출하는 것이 더 간단합니다.

결과에 쌍을 곱하려면 이전 값 (쌍)으로 돌아와야합니다. 이것은 포크 ( ])로 수행됩니다 . 포크는 일종의 스테로이드 고리입니다. 당신이 그 (것)들에게 두 가지 기능을 제공하는 경우 f와 g, 그들은 계산하는 이항 함수를 나타냅니다 f(a, g(a, b)). 우리의 경우, a제품 / 합계 쌍이고 b, 현재 입력 값이며, g우리의 분할 성 테스트이며 f곱셈입니다. 따라서이 모든 것이 계산 [p, s] * ([p, s] % x == [0, 0])됩니다.

이제 남은 것은 이터레이터에서 사용 된 테스트 함수의 최종 값인 첫 번째 값을 추출하는 것입니다. 이것은 head 함수로 &포크를 작성 ( )하는 것만 큼 ​​간단 합니다.리스트의 첫 번째 값을 리턴합니다.<

R, 132115 바이트

@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(...)

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

자바 스크립트 (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

자바 스크립트 (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

하스켈, 94 85 72 71 바이트

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

1- 색인.

13 바이트를 절약 한 @Zgarb에게 감사합니다!

바이트를 저장해 준 @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

자바 스크립트 (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 초 소요).

파이썬 2, 122110 바이트

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 인터프리터를 사용해야합니다.

Wonder, 33 바이트

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

인덱스가 0입니다. 용법:

(@:^#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)메모리를 유출하고 호출 당 한 번 초기화되지 않은 메모리에 액세스하지만 segfault를 수행하지 않고 올바른 숫자를 반환합니다.

./prog $(seq 1 10)ungolfed (kinda)를 사용하여 단항 ( 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)는 x가 기준에 맞는 경우 True를 반환하는 함수입니다.

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

반복 솔루션. 0이 아닌 $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)있다 모두 제로인은 또한도 0이된다, 따라서 부울 아닌 따라서 진실 것이다 $n감소된다.

루프를 종료하면 (즉, n 번째 항에 도달하면 ) $a파이프 라인에 배치하기 만하면 출력이 내재됩니다.

예

참고 :이 토스 무리 기본적으로 무시 STDERR에 오류가 "0으로 시도 나누기"의를. 2>$null출력을 정리하기 위해 아래 예제 에 a 를 명시 적으로 추가했습니다 . 그것은 약 도착하면 꽤 느린도의 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