Lấy một số nguyên dương X. Số này là một phần của chuỗi chúng tôi quan tâm nếu tổng của tất cả các chữ số Xlà một ước của Xvà nếu tích của tất cả các chữ số Xlà một ước của X.

Ví dụ, 135là một số như vậy bởi vì 1 + 3 + 5 = 9phân chia 135 = 9 * 15và 1 * 3 * 5 = 15cũng chia 135.

Đây là trình tự A038186 trong OEIS.

Nhiệm vụ của bạn: được cung cấp một số nguyên N, xuất Nsố nguyên dương thứ th với các thuộc tính như vậy.

Đầu vào và đầu ra

• Các số có thể được xác định 0hoặc tìm kiếm 1; vui lòng cho biết câu trả lời của bạn sử dụng.

• Đầu vào có thể được thực hiện thông qua STDIN, như là một đối số chức năng, hoặc bất cứ điều gì tương tự.

• Đầu ra có thể được in tới STDOUT, trả về từ một chức năng hoặc bất cứ thứ gì tương tự.

Các trường hợp thử nghiệm

Các trường hợp thử nghiệm dưới đây là 1-exexed.

Input        Output

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

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

05AB1E , 13 12 byte

Cảm ơn Emigna vì đã tiết kiệm một byte!

µNNSONSP‚ÖP½

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Pyke, 14 byte (không cạnh tranh) (1 chỉ mục)

~1IY'sB]im%X)@

Hãy thử nó ở đây!

Trời ơi thật nhiều tính năng mới.

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

Trong đó không cạnh tranh

• một lỗi trong Iđó nó sẽ chỉ kiểm tra xem mục đầu tiên trên ngăn xếp có đúng không
• digits - trả về danh sách các chữ số trong số
• @ được sử dụng để có được mục thứ n của danh sách vô hạn

Trong số đó đã được sử dụng lần đầu tiên:

• tất cả những điều trên
• danh sách vô hạn

Xóa 2 byte cuối cùng để có được tất cả các số này.

C #, 118 byte

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

Chương trình đầy đủ với chức năng vô căn cứ và các trường hợp thử nghiệm:

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

Thạch , 13 byte

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

1 dựa.
Dùng thử trực tuyến!

Làm sao?

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 byte (được lập chỉ mục 0)

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

Giải trình:

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

Danh sách vô hạn ftw!

Thực ra , 20 byte

Thực hiện ngây thơ của định nghĩa trình tự. Gợi ý chơi golf chào mừng! Hãy thử trực tuyến!

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.

Sứa , 45 byte

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

Hãy thử trực tuyến!

Giải trình

Đây là chương trình phức tạp nhất (và cũng dài nhất) mà tôi đã viết trong Jellyfish cho đến nay. Tôi không biết liệu tôi có thể phá vỡ điều này một cách dễ hiểu hay không, nhưng tôi đoán tôi sẽ phải thử.

Sứa cung cấp một nhà điều hành lặp đi lặp lại khá chung, \mà sẽ giúp rất nhiều với "tìm kiếm thứ N một cái gì đó ". Một trong những ngữ nghĩa của nó là "lặp một hàm trên một giá trị cho đến khi một hàm kiểm tra riêng biệt mang lại sự thật" (thực tế, hàm kiểm tra nhận được cả phần tử hiện tại và phần tử cuối cùng, nhưng chúng ta sẽ chỉ nhìn vào phần tử hiện tại) . Chúng ta có thể sử dụng điều này để thực hiện chức năng "số hợp lệ tiếp theo". Một tình trạng quá tải khác \là "lặp một hàm trên giá trị bắt đầu N lần". Chúng ta có thể sử dụng hàm trước đó và lặp lại nó trên 0N lần, trong đó N là đầu vào. Tất cả điều đó được thiết lập khá chính xác với phần mã này:

p
\Ai
\&
>     0

(Lý do tại sao 0, đầu vào thực tế cho hàm kết quả, có một chút phức tạp và tôi sẽ không đi sâu vào chúng ở đây.)

Vấn đề với tất cả những điều này là, chúng tôi sẽ không chuyển giá trị hiện tại cho chức năng kiểm tra theo cách thủ công. Nhà \điều hành sẽ làm điều này cho chúng tôi. Vì vậy, bây giờ chúng ta đã xây dựng một hàm unary duy nhất (thông qua các thành phần, móc, dĩa và cà ri) lấy một số và cho chúng ta biết đó có phải là một số hợp lệ hay không (nghĩa là một số được chia cho tổng số chữ số và sản phẩm chữ số của nó). Điều này khá không tầm thường khi bạn không thể tham khảo đối số. Không bao giờ. Đó là vẻ đẹp này:

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

Đây (là một hook unary , có nghĩa là nó gọi hàm bên dưới ( f) trên đầu vào của nó (giá trị hiện tại x), và sau đó chuyển cả hai chúng sang hàm kiểm tra sang phải ( g), nghĩa là nó tính toáng(f(x), x) .

Trong trường hợp của chúng tôi, f(x)là một hàm tổng hợp khác có được một cặp với sản phẩm chữ số và tổng chữ số của x. Điều đó có nghĩa là gsẽ là một hàm có cả ba giá trị để kiểm tra xem xcó hợp lệ không.

Chúng ta sẽ bắt đầu bằng cách xem xét cách ftính tổng sản phẩm và chữ số. Đây là f:

 &~b
  10
 ( )/*
 /+

&cũng là thành phần (nhưng cách khác vòng). ~là currying để 10~bcung cấp cho hàm tính các chữ số thập phân của một số và vì chúng ta chuyển nó sang &bên phải, đó là điều đầu tiên sẽ xảy ra với đầu vàox . Phần còn lại sử dụng danh sách các chữ số này để tính tổng và sản phẩm của chúng.

Để tính một tổng, chúng ta có thể gấp bổ sung trên đó, đó là /+. Tương tự như vậy, để tính toán sản phẩm, chúng tôi nhân bội với nó /*. Để kết hợp cả hai kết quả này thành một cặp, chúng tôi sử dụng một cặp móc (và ). Cấu trúc của nó là:

()g
f

(Nơi fvà glà sản phẩm và số tiền tương ứng.) Chúng ta hãy thử tìm hiểu tại sao điều này cho chúng ta một cặp f(x)và g(x). Lưu ý rằng hook bên phải )chỉ có một đối số. Trong trường hợp này, đối số khác được ngụ ý là ;bao bọc các đối số của nó trong một cặp. Hơn nữa, hook cũng có thể được sử dụng như các hàm nhị phân (sẽ là trường hợp ở đây) trong trường hợp chúng chỉ đơn giản áp dụng hàm bên trong cho một đối số. Vì vậy, thực sự )trên một chức năng duy nhất gcho một chức năng tính toán [x, g(y)]. Sử dụng cái này trong một cái móc trái, cùng với f, chúng ta có được [f(x), g(y)]. Điều này, lần lượt được sử dụng trong một bối cảnh đơn nhất, có nghĩa là nó thực sự được gọi với x == yvà vì vậy chúng tôi kết thúc với[f(x), g(x)] yêu cầu. Phù.

Điều đó chỉ để lại một điều, đó là chức năng kiểm tra trước đó của chúng tôi g. Hãy nhớ rằng nó sẽ được gọi là g([p, s], x)nơi xvẫn là giá trị đầu vào hiện tại, plà sản phẩm chữ số của nó và slà tổng số của nó. Đây là g:

  &]&|
  <*&d
    N

Để kiểm tra tính phân chia, rõ ràng chúng ta sẽ sử dụng modulo, có |trong Sứa. Đôi khi, một cách bất thường, nó lấy toán hạng bên phải của nó, toán hạng tay trái của nó, có nghĩa là các đối số gđã được sắp xếp theo thứ tự đúng (các hàm số học như thế này tự động xâu chuỗi các danh sách, vì vậy điều này sẽ tính toán hai mô đun riêng biệt miễn phí) . Số của chúng tôi chia hết cho cả sản phẩm và tổng, nếu kết quả là một cặp số không. Để kiểm tra xem đó có phải là trường hợp không, chúng tôi coi cặp này là một danh sách gồm 2 chữ số cơ bản ( d). Kết quả của giá trị này là 0, chỉ khi cả hai phần tử của cặp bằng 0, vì vậy chúng ta có thể phủ định kết quả của Ngiá trị này ( ) để có được giá trị trung thực cho cả hai giá trị có phân chia đầu vào hay không. Lưu ý rằng |, dvàNchỉ đơn giản là tất cả được sáng tác cùng với một cặp &s.

Thật không may, đó không phải là câu chuyện đầy đủ. Nếu sản phẩm chữ số bằng 0 thì sao? Chia và modulo bằng 0 đều trả về 0 trong Sứa. Mặc dù điều này có vẻ như là một quy ước hơi kỳ quặc, nhưng nó thực sự có vẻ hữu ích (vì chúng ta không cần kiểm tra số 0 trước khi thực hiện modulo). Tuy nhiên, điều đó cũng có nghĩa là chúng ta có thể nhận được dương tính giả, nếu tổng chữ số không chia đầu vào, nhưng sản phẩm chữ số bằng 0 (ví dụ: đầu vào 10).

Chúng tôi có thể khắc phục điều này bằng cách nhân kết quả chia hết của chúng tôi với sản phẩm chữ số (vì vậy nếu sản phẩm chữ số bằng 0, nó cũng sẽ biến giá trị trung thực của chúng tôi thành số 0). Hóa ra đơn giản hơn để nhân kết quả chia hết với cặp sản phẩm và tổng, và trích xuất kết quả từ sản phẩm sau đó.

Để nhân kết quả với cặp, chúng ta cần phải lấy lại ở giá trị trước đó (cặp). Điều này được thực hiện với một ngã ba ( ]). Dĩa giống như móc trên steroid. Nếu bạn cung cấp cho họ hai hàm fvà g, chúng đại diện cho hàm nhị phân tính toán f(a, g(a, b)). Trong trường hợp của chúng tôi, alà cặp sản phẩm / tổng, blà giá trị đầu vào hiện tại, glà phép thử chia hết của chúng tôi và flà phép nhân. Vì vậy, tất cả các tính toán này [p, s] * ([p, s] % x == [0, 0]).

Tất cả những gì còn lại bây giờ là trích xuất giá trị đầu tiên của giá trị này, đây là giá trị cuối cùng của hàm kiểm tra được sử dụng trong trình vòng lặp. Điều này đơn giản như việc soạn thảo ( &) ngã ba với hàm head< , trả về giá trị đầu tiên của danh sách.

R, 132 115 byte

Phiên bản mới nhờ @Billywob bình luận tốt đẹp!

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

Ung dung:

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

Vì R cư xử kỳ lạ với NAs, tôi phải thêm toàn bộ ifelse(is.na(...))!
Hoặc dùngna.omit(...)

Brachylog , 22 byte

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

Hãy thử trực tuyến!

Giải trình

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

Ít chơi gôn

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

Bình thường, 18 byte

e.f!.xs%LZsM*FBsM`

Dùng thử trực tuyến: Trình diễn

Giải trình:

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 byte

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

Bản giới thiệu

Nó có xu hướng chậm đối với các giá trị cao hơn, vì vậy tôi giới hạn ở mức 20 ở đây.

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 byte

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

1 chỉ mục.

Cảm ơn @Zgarb đã lưu 13 byte!

Cảm ơn @nimi vì đã tiết kiệm một byte!

MATL , 21 byte

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

Lâu dài và không hiệu quả ...

Hãy thử trực tuyến!

Làm thế nào nó hoạt độ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 byte

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

Điều này hóa ra khá giống câu trả lời của @ Arnauld, nhưng đệ quy rõ ràng là ngắn hơn 2 byte. Hoạt động trong Chrome, mặc dù nó rất chậm với các đầu vào lớn hơn 30 hoặc hơn (50 mất 6 giây).

Python 2, 122 110 byte

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 được lập chỉ mục, bạn cần sử dụng trình thông dịch Python với giới hạn đệ quy khá cao.

Kỳ quan, 33 byte

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

Không có chỉ mục. Sử dụng:

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

Giải trình

Dễ đọc hơn:

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

Về cơ bản có được một danh sách vô hạn các số chia hết cho tổng số và sản phẩm của nó bằng cách lọc một danh sách vô hạn các số nguyên thông qua một vị ngữ. Sau đó, nmục thứ chỉ đơn giản là chọn ra khỏi danh sách.

Julia, 81 byte

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)

Đây là một hàm ẩn danh chấp nhận một số nguyên và trả về một số nguyên. Để gọi nó, đặt tên cho nó. Cách tiếp cận là một cách rõ ràng: kiểm tra mọi số cho đến khi chúng tôi gặp phải ncác điều khoản của chuỗi. Cácall kiểm tra là cần thiết để đảm bảo chúng tôi không nhận được mộtDivisionError từ% khi tích của các chữ số là 0.

Ung dung:

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

Hãy thử trực tuyến! (bao gồm tất cả các trường hợp thử nghiệm)

C89, 381 226 195 170 169 byte

1 chỉ mục (cùng câu trả lời chính xác như trong thử thách).

Giả sử 4 byte (32 bit)int (hầu hết các kiến ​​trúc hiện đại) .

Tôi thực sự tin rằng điều này không thể đi ngắn hơn.

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

Chức năng int g (int)rò rỉ bộ nhớ và truy cập bộ nhớ chưa được khởi tạo một lần cho mỗi cuộc gọi nhưng không segfault và trả về đúng số.

Chương trình đầy đủ nhận đầu vào trong unary ( ./prog $(seq 1 10)cho 10) với unolfed (kinda):

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

Câu trả lời cũ:

C99, 381 byte

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

Điều này có thể có thể được chơi golf nhiều hơn.

Chương trình đầy đủ:

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

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 và cách sử dụng:

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 byte

Phiên bản mới nhờ 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))

Mã mới, tôi nhớ một cách chơi golf để làm giai thừa

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

Bản thân mã không giống như golf, giống như golf mạnh hơn

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) là hàm trả về True nếu x phù hợp với tiêu chí.

PHP, 96 byte

Đưa ra nnhư là một đối số dòng lệnh.

Chơi gôn

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

Bị đánh cắp

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 byte

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

Giải pháp lặp lại. Đưa đầu vào $nvà vào một forvòng lặp miễn $nlà không bằng không. Mỗi lần lặp lại, chúng tôi trừ đi $nkết quả của một câu lệnh Boolean, được chia ra dưới đây:

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

Như vậy, chỉ khi nào $a%(sum)và $a%(product)được cả hai bằng không sẽ bổ sung cũng được không, và do đó Boolean-không sẽ được True và do đó $nđược giảm đi.

Khi chúng tôi thoát khỏi vòng lặp (nghĩa là chúng tôi đạt đến thuật ngữ thứ n ), chúng tôi chỉ cần đặt $atrên đường ống và đầu ra là ẩn.

Ví dụ

Lưu ý: Điều này ném một loạt các lỗi "Đã cố chia cho 0" cho STDERR, mặc định bị bỏ qua. Tôi đã thêm một cách rõ ràng vào 2>$nullví dụ dưới đây để dọn sạch đầu ra. Nó cũng khá chậm một khi nó đạt được khoảng chừng 30đó và 50mất khoảng 45 giây trên máy của tôi.

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 byte

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