Nehmen Sie eine positive ganze Zahl X. Diese Zahl ist Teil der Sequenz, an der wir interessiert sind, wenn die Summe aller Ziffern Xein Teiler von Xist und wenn das Produkt aller Ziffern Xein Teiler von ist X.

Zum Beispiel 135ist eine solche Zahl, weil 1 + 3 + 5 = 9die sich teilt 135 = 9 * 15und 1 * 3 * 5 = 15die sich auch teilt 135.

Dies ist die Sequenz A038186 im OEIS.

Ihre Aufgabe: Geben Sie bei einer Ganzzahl Ndie Ndritte positive Ganzzahl mit solchen Eigenschaften aus.

Eingänge und Ausgänge

• Zahlen können 0-indexiert oder 1-indexiert sein; Bitte geben Sie an, welche Antwort Sie verwenden.

• Die Eingabe kann STDINals ein Funktionsargument oder etwas Ähnliches durchgenommen werden.

• Die Ausgabe kann auf STDOUTeine Funktion oder auf eine ähnliche Weise gedruckt oder von dieser zurückgegeben werden.

Testfälle

Die folgenden Testfälle sind 1indiziert.

Input        Output

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

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

05AB1E , 13 12 Bytes

Danke an Emigna für das Speichern eines Bytes!

µNNSONSP‚ÖP½

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Pyke, 14 Bytes (nicht konkurrierend) (1-indiziert)

~1IY'sB]im%X)@

Probieren Sie es hier aus!

Mein Gott, was für viele neue Funktionen.

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

Davon sind nicht wettbewerbsfähig

• Ein Bugfix, bei Idem nur geprüft wurde, ob das erste Element auf dem Stapel wahr ist
• digits - Eine Liste der Ziffern in der Nummer zurückgeben
• @ Dient zum Abrufen des n-ten Elements einer unendlichen Liste

Davon wurden zum ersten Mal verwendet:

• Alles das oben Genannte
• unendliche Listen

Entfernen Sie die letzten 2 Bytes, um alle diese Zahlen zu erhalten.

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

Volles Programm mit ungolfed Funktion und Testfällen:

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

Jelly , 13 Bytes

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

1-basiert.
TryItOnline!

Wie?

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 (0-indiziert)

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

Erläuterung:

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

Unendliche Listen ftw!

Eigentlich 20 Bytes

Naive Implementierung der Sequenzdefinition. Golfvorschläge willkommen! Probieren Sie es online!

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.

Qualle , 45 Bytes

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

Probieren Sie es online!

Erläuterung

Dies ist mit Abstand das aufwändigste (und auch längste) Programm, das ich bisher in Jellyfish geschrieben habe. Ich habe keine Ahnung, ob ich das verständlich aufschlüsseln kann, aber ich denke, ich muss es versuchen.

Jellyfish bietet einen ziemlich allgemeinen Iterationsoperator \, der beim "Finden des N-ten Etwas " sehr hilfreich ist . Eine seiner Semantiken ist "eine Funktion auf einem Wert iterieren, bis eine separate Testfunktion etwas Wahres ergibt" (in der Tat empfängt die Testfunktion sowohl das aktuelle als auch das letzte Element, aber wir lassen es nur das aktuelle Element betrachten). . Wir können dies verwenden, um eine Funktion "Nächste gültige Nummer" zu implementieren. Eine weitere Überladung von \ist "N-mal eine Funktion auf einem Startwert iterieren". Wir können unsere vorherige Funktion verwenden und sie 0N-mal durchlaufen , wobei N die Eingabe ist. All das ist ziemlich genau mit diesem Teil des Codes zusammengestellt:

p
\Ai
\&
>     0

(Die Gründe, warum 0die eigentliche Eingabe für die resultierende Funktion dort drüben ist, sind etwas kompliziert und ich werde hier nicht darauf eingehen.)

Das Problem dabei ist, dass wir den aktuellen Wert nicht manuell an die Testfunktion übergeben. Der \Betreiber wird dies für uns tun. Also haben wir jetzt eine einzige unäre Funktion (über Kompositionen, Haken, Gabeln und Curry), die eine Zahl aufnimmt und uns sagt, ob es eine gültige Zahl ist (dh eine, die durch ihre Ziffernsumme und ihr Ziffernprodukt geteilt wird). Dies ist ziemlich nicht trivial, wenn Sie sich nicht auf das Argument beziehen können. Je. Es ist diese Schönheit:

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

Das (ist ein unärer Hook , was bedeutet, dass es die Funktion below ( f) an seinem Eingang aufruft (den aktuellen Wert x) und dann beide an die Testfunktion rechts ( g) übergibt , das heißt, es berechnet g(f(x), x).

In unserem Fall f(x)handelt es sich um eine andere zusammengesetzte Funktion, die ein Paar mit dem Ziffernprodukt und der Ziffernsumme von ergibt x. Das heißt, es gwird eine Funktion sein, die alle drei Werte hat, um zu prüfen, ob sie xgültig ist.

Wir beginnen damit, wie fdie Ziffernsumme und das Ziffernprodukt berechnet werden. Das ist f:

 &~b
  10
 ( )/*
 /+

&ist auch Komposition (aber umgekehrt). ~Wenn Sie mit currying arbeiten, erhalten Sie 10~beine Funktion, die die Dezimalstellen einer Zahl berechnet, und da wir diese &von rechts übergeben, passiert das als Erstes mit der Eingabe x. Der Rest verwendet diese Ziffernliste, um die Summe und das Produkt zu berechnen.

Um eine Summe zu berechnen, können wir falten zusätzlich darüber, was ist /+. Um das Produkt zu berechnen, falten wir die Multiplikation mit /*. Um diese beiden Ergebnisse zu einem Paar zu kombinieren, verwenden wir ein Paar Hooks (und ). Die Struktur hierfür ist:

()g
f

(Wo fund gsind Produkt bzw. Summe.) Versuchen wir herauszufinden, warum dies uns ein Paar von f(x)und gibt g(x). Beachten Sie, dass der rechte Haken )nur ein Argument hat. In diesem Fall bedeutet das andere Argument, dass es ;die Argumente in ein Paar einschließt. Außerdem können Hooks auch als Binärfunktionen verwendet werden (was hier der Fall sein wird). In diesem Fall wenden sie einfach die innere Funktion nur auf ein Argument an. Also wirklich )auf eine einzige Funktion ggibt eine Funktion, die berechnet [x, g(y)]. Wenn fwir dies in einem linken Haken zusammen mit verwenden , erhalten wir [f(x), g(y)]. Dies wird wiederum in einem unären Kontext verwendet, was bedeutet, dass es tatsächlich mit aufgerufen wird x == yund wir am Ende mit [f(x), g(x)]wie erforderlich enden . Puh.

Damit bleibt nur eines übrig, nämlich unsere frühere Testfunktion g. Erinnern Sie sich, dass es aufgerufen wird, als g([p, s], x)wo xnoch der aktuelle Eingabewert ist, pist sein stelliges Produkt und sist seine stellige Summe. Das ist g:

  &]&|
  <*&d
    N

Um die Teilbarkeit zu testen, verwenden wir natürlich Modulo, das |in Jellyfish enthalten ist. Etwas ungewöhnlich ist, dass es seinen rechten Operanden modulo als linken Operanden verwendet, was bedeutet, dass die Argumente gbereits in der richtigen Reihenfolge vorliegen (arithmetische Funktionen wie diese ziehen sich automatisch über Listen, sodass die beiden separaten Module kostenlos berechnet werden). . Unsere Zahl ist sowohl durch das Produkt als auch durch die Summe teilbar, wenn das Ergebnis ein Nullenpaar ist. Um zu überprüfen, ob dies der Fall ist, behandeln wir das Paar als eine Liste von Basis-2-Ziffern ( d). Das Ergebnis davon ist Null, nur wenn beide Elemente des Paares Null sind. Daher können wir das Ergebnis von this ( N) negieren , um einen Wahrheitswert dafür zu erhalten, ob beide Werte die Eingabe teilen. Beachten Sie, dass |, dundNsind einfach alle zusammen mit einem Paar von &s zusammengesetzt.

Leider ist das nicht die ganze Geschichte. Was ist, wenn das Ziffernprodukt Null ist? Division und Modulo durch Null geben beide Null in Jellyfish zurück. Während dies wie eine etwas seltsame Konvention erscheint, erweist es sich tatsächlich als etwas nützlich (da wir nicht auf Null prüfen müssen, bevor wir das Modulo ausführen). Es bedeutet jedoch auch, dass wir ein falsches Positiv erhalten können, wenn die Ziffernsumme die Eingabe teilt, das Ziffernprodukt jedoch Null ist (z 10. B. Eingabe ).

Wir können dies beheben, indem wir unser Divisionsergebnis mit dem Zahlenprodukt multiplizieren (wenn also das Zahlenprodukt Null ist, wird unser Wahrheitswert ebenfalls zu Null). Es erweist sich als einfacher, das Ergebnis der Teilbarkeit mit dem Paar aus Produkt und Summe zu multiplizieren und anschließend das Ergebnis aus dem Produkt zu extrahieren.

Um das Ergebnis mit dem Paar zu multiplizieren, müssen wir zu einem früheren Wert zurückkehren (dem Paar). Dies geschieht mit einer Gabel ( ]). Gabeln sind ein bisschen wie Haken an Steroiden. Wenn Sie ihnen zwei Funktionen fund geben g, stellen sie eine Binärfunktion dar, die berechnet f(a, g(a, b)). In unserem Fall aist das Produkt / Summen-Paar bder aktuelle Eingabewert, gunser Teilbarkeitstest und fdie Multiplikation. Das alles berechnet sich also [p, s] * ([p, s] % x == [0, 0]).

Jetzt müssen Sie nur noch den ersten Wert daraus extrahieren, den Endwert der im Iterator verwendeten Testfunktion. Dies ist so einfach wie das Erstellen ( &) der Verzweigung mit der head- Funktion <, die den ersten Wert einer Liste zurückgibt.

R, 132 115 Bytes

Neue Version dank @Billywob nette Kommentare!

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

Ungolfed:

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

Da R sich mit NAs seltsam verhält , musste ich den ganzen ifelse(is.na(...))Teil hinzufügen !
Oder benutzena.omit(...)

Brachylog , 22 Bytes

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

Probieren Sie es online!

Erläuterung

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

Weniger golfen

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`

Probieren Sie es online aus: Demonstration

Erläuterung:

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

Demo

Bei höheren Werten ist der Wert in der Regel langsam, daher beschränke ich ihn hier auf 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 Bytes

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

1-indiziert.

Vielen Dank an @Zgarb für das Speichern von 13 Bytes!

Vielen Dank an @nimi für das Speichern eines Bytes!

MATL , 21 Bytes

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

Lang und ineffizient ...

Probieren Sie es online!

Wie es funktioniert

`        % 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

Dies stellte sich als ziemlich ähnlich wie die Antwort von @ Arnauld heraus, aber die Rekursion ist anscheinend 2 Bytes kürzer. Funktioniert in Chrome, obwohl es bei Eingaben über 30 sehr langsam ist (50 dauert 6 Sekunden).

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 indiziert, müssen Sie einen Python-Interpreter mit einer recht hohen Rekursionsgrenze verwenden.

Wunder, 33 Bytes

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

Nullindexiert. Verwendung:

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

Erläuterung

Besser lesbar:

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

Grundsätzlich erhält man eine unendliche Liste von Zahlen, die durch ihre digitale Summe und ihr Produkt teilbar sind, indem man eine unendliche Liste von ganzen Zahlen durch ein Prädikat filtert. Dann wird der ndritte Punkt einfach aus der Liste genommen.

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)

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und eine Ganzzahl zurückgibt. Um es zu nennen, geben Sie ihm einen Namen. Der Ansatz ist der naheliegende: Überprüfen Sie jede Zahl, bis wir nBegriffe der Sequenz gefunden haben. Die allÜberprüfung ist notwendig , um sicherzustellen , dass wir nicht bekommen , eine DivisionErroraus , %wenn das Produkt aus den Ziffern 0.

Ungolfed:

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

Probieren Sie es online! (beinhaltet alle Testfälle)

C89, 381 226 195 170 169 Bytes

1-indiziert (gleiche exakte Antworten wie bei der Challenge).

Nimmt 4 Byte (32 Bit) anint (modernste Architekturen) .

Ich glaube wirklich, dass dies nicht kürzer gehen kann.

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

Die Funktion führt int g (int)zu einem Speicherverlust und greift einmal pro Anruf auf den nicht initialisierten Speicher zu, führt jedoch keinen Fehler aus und gibt die richtige Nummer zurück.

Vollständiges Programm, das Eingaben in unary ( ./prog $(seq 1 10)für 10) mit ungolfed (irgendwie) aufnimmt:

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

Alte Antwort:

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

Damit kann wohl mehr golfen werden.

Volles Programm:

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

Ungolfed und Nutzung:

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

Neue Version dank 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))

Neuer Code, ich erinnerte mich an eine spielerische Art, die Fakultät zu spielen

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

Der Code selbst ist nicht sehr golfartig, eher wie Brute-Force-Golf

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) ist eine Funktion, die True zurückgibt, wenn x den Kriterien entspricht.

PHP, 96 Bytes

Dient nals Befehlszeilenargument.

Golf gespielt

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

Ungolfed

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

Iterative Lösung. Übernimmt die Eingabe $nund tritt in eine forSchleife ein, solange sie $nnicht Null ist. Jede Iteration subtrahieren wir vom $nErgebnis einer Booleschen Anweisung, die im Folgenden aufgeführt ist:

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

Somit wird nur , wenn $a%(sum)und $a%(product)sind beide gleich Null wird der Zusatz sein auch Null und damit die Boolesche-nicht wird wahr sein , und deshalb $nverringert.

Sobald wir die Schleife verlassen (dh den n-ten Term erreicht haben), platzieren wir sie einfach $ain der Pipeline, und die Ausgabe ist implizit.

Beispiele

Hinweis: Dadurch werden STDERR eine Reihe von Fehlern "Versucht, durch Null zu dividieren" übergeben, die standardmäßig ignoriert werden. Ich habe 2>$nulldem folgenden Beispiel explizit ein hinzugefügt , um die Ausgabe zu bereinigen. Es ist auch ziemlich langsam, sobald es ungefähr 30so weit ist, und 50dauert ungefähr 45 Sekunden auf meinem Computer.

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