正の整数を取りXます。この数は、のすべての数字の合計Xがの約数でありX、のすべての数字の積がの約数である場合に関心のあるシーケンスの一部XですX。

たとえば、135が1 + 3 + 5 = 9分割され135 = 9 * 15、1 * 3 * 5 = 15が分割されるため、このような数値135です。

これは、OEISのシーケンスA038186です。

あなたのタスク：整数が与えられると、そのようなプロパティをもつ正の整数をN出力しNます。

入力と出力

• 番号には0-indexedまたは1-indexedを使用できます。回答のどれを使用するかを指定してください。

• 入力はSTDIN、を介して、関数の引数などとして取得できます。

• 出力は、に出力されSTDOUTたり、関数から返されたり、類似したものになります。

テストケース

以下のテストケースは1-indexedです。

Input        Output

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

得点

これはcode-golfであるため、バイト単位の最短回答が優先されます。

05AB1E、13 12バイト

バイトを保存してくれたエミグナに感謝します！

µ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

無限リスト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は、かなり一般的な反復演算子を提供します\。これは、「N番目の何かを見つける」のに役立ちます。そのセマンティクスの1つは、「個別のテスト関数が何らかの真実を示すまで値の関数を繰り返す」です（実際、テスト関数は現在の要素と最後の要素の両方を受け取りますが、現在の要素のみを参照します） 。これを使用して、「次の有効な番号」関数を実装できます。のもう1つのオーバーロード\は、「開始値で関数をN回繰り返す」です。以前の関数を使用して、0N回入力することができます（Nは入力）。これらはすべて、コードのこの部分でかなり簡潔に設定されています。

p
\Ai
\&
>     0

（0結果の関数への実際の入力が終わる理由は少し複雑で、ここでは説明しません。）

これらすべての問題は、現在の値を手動でテスト関数に渡さないことです。\オペレータは、私たちのためにこれを行います。したがって、数字を受け取り、それが有効な数字（数字の合計と数字の積で除算される数字）であるかどうかを判断する単一の単項関数（コンポジション、フック、フォーク、カリー）を作成しました。引数を参照できない場合、これはかなり重要です。今まで。この美しさです：

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

(単項あるフックそれは（以下の関数を呼び出すことを意味し、fその入力（現在値に）x）、右（にテスト機能にそれらの両方を通過するgことは計算です）g(f(x), x)。

私たちの場合、f(x)は、の積と数字の合計とのペアを取得する別の複合関数ですx。つまりg、x有効かどうかをチェックする3つの値すべてを持つ関数になります。

まずf、数字の合計と数字の積を計算する方法を見ていきます。これはf：

 &~b
  10
 ( )/*
 /+

&構成でもあります（ただし逆です）。~はカリー化されているため10~b、数値の小数桁を計算する関数を提供します。これを&右から渡しているため、inputに最初に起こることxです。残りは、この数字のリストを使用して、合計と積を計算します。

合計を計算するために、我々はできる倍である、その上に追加します/+。同様に、積を計算するために、乗算で乗算を折り返し/*ます。ペアに、これらの結果の両方を組み合わせることが、我々は、一対のフックを使用し、(そして)。この構造は次のとおりです。

()g
f

（どこfとg積との和は、それぞれ。）これは、私たちのペアを与える理由を把握するためにレッツ・トライf(x)とg(x)。右フックに)は引数が1つしかありません。この場合、他の引数は;、引数をペアでラップすることを意味します。さらに、フックはバイナリ関数として使用することもできます（この場合）、1つの引数にのみ内部関数を適用します。したがって、実際)には単一の関数でgを計算する関数が得られ[x, g(y)]ます。これをとともに左フックで使用してf、を取得し[f(x), g(y)]ます。これは、単項コンテキストで使用されます。つまり、実際に呼び出されるx == yため[f(x), g(x)]、必要に応じて終了します。ふう。

残っているのは、以前のテスト関数gでした。まだ現在の入力値であり、その数字の積であり、その数字の合計g([p, s], x)であると呼ばれることを思い出してください。これは：xpsg

  &]&|
  <*&d
    N

可分性をテストするために、明らか|にJellyfish にあるモジュロを使用します。やや異常に、それは右オペランドを左オペランドを法として取ります。これは、への引数gが既に正しい順序にあることを意味します（このような算術関数はリストを自動的にスレッド化するので、2つの別々のモジュラスを無料で計算します） 。結果がゼロのペアの場合、数は積と合計の両方で割り切れます。それが当てはまるかどうかを確認するために、ペアを2進数のリスト（d）として扱います。ペアの両方の要素がゼロの場合にのみ、この結果はゼロになるため、この結果（N）を否定して、両方の値が入力を分割するかどうかの真理値を取得できます。なお|、d及びN単純にすべてのペアで構成されてい&ます。

残念ながら、それは完全な話ではありません。数字の積がゼロの場合はどうなりますか？ゼロによる除算およびモジュロは、両方ともクラゲでゼロを返します。これはやや奇妙な慣習のように思えるかもしれませんが、実際にはいくらか有用であることがわかります（モジュロを行う前にゼロをチェックする必要がないため）。ただし、数字の合計が入力を除算するが、数字の積がゼロ（入力など10）の場合、偽陽性になる可能性もあります。

これを修正するには、割り切れる結果に数字の積を掛けます（数字の積がゼロの場合、真理値もゼロになります）。割り切れる結果を積と和のペアで乗算し、後で結果を製品から抽出する方が簡単であることがわかりました。

結果にペアを掛けるには、以前の値（ペア）に戻る必要があります。これはfork（]）で行われます。フォークは、ステロイドのフックのようなものです。それらに2つの関数fとを与えた場合g、それらは計算するバイナリ関数を表しf(a, g(a, b))ます。この場合、aは積/合計のペア、b現在の入力値、g分割可能性テスト、およびf乗算です。したがって、このすべてが計算され[p, s] * ([p, s] % x == [0, 0])ます。

残っているのは、この最初の値を抽出することだけです。これは、反復子で使用されるテスト関数の最終値です。これは、リストの最初の値を返すhead関数&を使用してforkを構成する（）のと同じくらい簡単です。<

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

アンゴルフド：

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インデックス付き。

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

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秒かかります）。

パイソン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-indexed（チャレンジと同じ正確な答え）。

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)メモリをリークし、呼び出しごとに初期化されていないメモリに1回アクセスしますが、セグメンテーション違反は発生せず、正しい数値を返します。

./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