取一个正整数X。这个数字是我们感兴趣的是，如果中的所有数字之和流程的一部分X是一个约数X，而如果所有的数字产品X是除数X。

例如，135是这样的数，因为1 + 3 + 5 = 9其将135 = 9 * 15与1 * 3 * 5 = 15这也分歧135。

这是OEIS中的序列A038186。

您的任务：给定一个整数N，输出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编码。在线尝试！

Pyke，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。
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

无限列表！

实际上，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
 ( )/+
 /*

在线尝试！

说明

到目前为止，这是我用水母编写的最详尽（也是最长）的程序。我不知道我是否能够以一种可以理解的方式将其分解，但是我想我必须尝试一下。

水母提供了一个相当通用的迭代运算符，\它对“找到第N个东西 ” 有很大帮助。它的语义之一是“在一个值上迭代一个函数，直到一个单独的测试函数给出真实的结果为止”（实际上，测试函数同时接收当前元素和最后一个元素，但我们只让它查看当前元素） 。我们可以使用它来实现“下一个有效数字”功能。的另一个重载\是“在起始值上迭代函数N次”。我们可以使用以前的函数，并对其进行0N次迭代，其中N为输入。所有这些都通过代码的这一部分非常简洁地设置：

p
\Ai
\&
>     0

（为什么 0要对结果函数进行实际输入，有点复杂，我这里不再赘述。）

所有这些的问题是，我们不会将当前值手动传递给测试函数。该\操作会为我们做到这一点。因此，我们现在构造了一个一元函数（通过组合，钩子，叉子和currying），该函数接受一个数字并告诉我们它是否是有效数字（即一个被其数字和与数字乘积所除的数字）。当您不能引用该参数时，这是相当重要的。曾经 是这样的美丽：

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

的(是一元钩，这意味着它调用下面的功能（f在其输入端）（电流值x），然后再通过两者的测试功能向右（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)]根据需要。ew

剩下的只有一件事，那就是我们之前的测试功能g。回想一下，它会被称为g([p, s], x)那里x仍然是当前的输入值，p是它的数字产品和s是它的数字和。这是g：

  &]&|
  <*&d
    N

为了测试可除性，显然我们将使用|水母中的模数。有点不同寻常的是，它的右操作数取左操作数为模，这意味着to的参数g已经按正确的顺序排列（这样的算术函数会自动遍历列表，因此这将免费计算两个独立的模数） 。如果结果是一对零，则我们的数字可乘以乘积和总和。要检查是否存在这种情况，我们将这对货币对视为以2为基数的数字（d）的列表。仅当该对中的两个元素均为零时，此结果才为零，因此我们可以对this（N）的结果求反，以获取两个值是否均分输入的真实值。请注意，|，d和N全部由一对组成&。

不幸的是，这还不是全部。如果数字积为零怎么办？在水母中，除以零和取模的值都返回零。尽管这似乎有些奇怪，但实际上却很有用（因为在做模之前，我们不需要检查零）。但是，这也意味着，如果数字总和确实除了输入，但数字乘积为零（例如input 10），则我们可能会得到误报。

我们可以通过将除数结果乘以数字乘积来解决此问题（因此，如果数字乘积为零，也会将真实值也变为零）。事实证明，将除数结果与乘积和和对相乘，然后从乘积中提取结果会更简单。

要将结果与该对相乘，我们需要回到较早的值（该对）。这是通过叉子（]）完成的。叉子有点像类固醇的钩子。如果给它们两个函数f和g，它们表示一个计算的二进制函数f(a, g(a, b))。在我们的例子中，a是乘积/总和对，b是当前输入值，g是我们的除数检验，并且f是乘法。因此，所有这些计算[p, s] * ([p, s] % x == [0, 0])。

现在剩下的就是提取它的第一个值，它是迭代器中使用的测试函数的最终值。这就像&用head函数组成（）fork 一样简单<，它返回列表的第一个值。

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

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

零索引。用法：

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

迭代解决方案。只要不为零，就接受输入$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在下面的示例中明确添加了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