Zahlen, die durch die Summe und das Produkt ihrer Ziffern teilbar sind


24

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 , also gewinnt die kürzeste Antwort in Bytes.


Wäre es in Ordnung, jede Zahl auszudrucken, wenn Sie sie gegen n = unendlich berechnen?
Blue

@BlueEyedBeast Nein, Sie müssen eine Eingabe vornehmen und die entsprechende Nummer zurückgeben.
Fatalize

Ist das Produkt aus den Ziffern 0 oder 1 bei der Prüfung von 10?
George

2
@ George sein Produkt ist 0.
Fatalize

Kann ich den Bereich der Eingabe beliebig einschränken, wenn die obere Grenze des Bereichs sowieso nicht vor dem Hitzetod des Universums berechnet werden würde?
Katze

Antworten:


11

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!


µNNSONSP‚ÖP½funktioniert auch, nicht wahr?
Emigna

@Emigna Schöne! Danke :)
Adnan

5

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.


4

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

1
for(int x=0,c=0;;)Spart Ihnen 1 Byte.
Raznagul

4

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)

4

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!


@ Joshua danke, aber diese Eltern sind notwendig für den Vorrang. Außerdem würde die Verwendung eines seltsamen Symbols anstelle von *mehr Bytes bedeuten.
Ven

Verdammt, ich habe vergessen zu überprüfen, ob es eine Perl 6-Antwort vor dem Posten hatte. Auch ich würde Fehler behandeln, indem ich //0in dem grepBlock verwende.
Brad Gilbert b2gills

@ BradGilbertb2gills Zögern Sie nicht, eine bessere Version zu veröffentlichen! Ich habe es nicht verwendet, //0weil es normalerweise in Codegolf akzeptiert wird, um auf stderr zu drucken.
Ven

Es war buchstäblich genau das gleiche, außer//0
Brad Gilbert b2gills

3

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.

3

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.


Als Schöpfer der Qualle stimme ich dieser Botschaft zu. (Wirklich, ich würde die Geduld verlieren, wenn ich diese Herausforderung in Jellyfish lösen würde.)
Zgarb

3

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


1
n=scan();b=i=0;while(i<n){b=b+1;d=strtoi(el(strsplit(c(b,""),"")));if(!b%%sum(d)&ifelse(is.na((p=!b%%prod(d))),F,p))i=i+1};bspart ein paar Bytes von: el(...)statt [[1]], indem c(b,"")statt paste(b), negiert die logische Ausdrücke !statt ==0und die geschweiften Klammern auf der Skipping - ifAnweisung. Ich vermute, dass es eine einfachere Möglichkeit geben sollte, mit dem NAProblem umzugehen, aber etwas Kluges nicht herausfinden konnte.
Billywob

1
Es hat sich herausgestellt, dass wir dies umgehen können, indem wir 0an den in der ifAnweisung ausgewerteten Ausdruck ein anhängen . Dies gibt jedoch eine Warnung zurück, wenn das Produkt nicht gleich ist 0. 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
Billywob

@ Billywob Vielen Dank! Ich wusste es nicht el(...)!
Frédéric

2

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

2

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
}  

2

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

2

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.


2

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!


(==)=<<map(gcd n)$[sum k,product k]sollte einige Bytes sparen.
Zgarb

Und während wir das tun, [sum k,product k]kann es sein map($read.pure<$>show n)[sum,product].
Zgarb

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

1

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

1

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


1

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.


1

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.


1

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)


Sie können durch die Zuordnung zwei Bytes speichern prod(d)zu poder etwas und dann ersetzt das all(d.>0)mit p>0. Und Sie können ein anderes speichern, indem Sie das i%sum(d)auf die andere Seite des 1ie bewegen p<1>i%sum(d).
Martin Ender

1

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

tio.run/nexus/… generiert einige Warnungen, aber es ist äquivalent. Ich denke jedoch, dass es in Ordnung ist, es intfür alles zu verwenden, da es der standardmäßige Integer-Typ ist.
Dennis

@Dennis Ich bin es nicht gewohnt, Überschriften auszulassen und Warnungen außerhalb von C89 zu ignorieren. Deshalb spiele ich mit allen aktivierten Warnungen und als Fehler: P Ich schreibe jedoch in C89 um.
Katze

@ Tennis Fixed: D
cat

1

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

1

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.


Verwenden Sie in Zukunft <1anstelle von ==0. Sie brauchen die is Trueif-Anweisung nicht, um zu prüfen, ob die Bedingung trotzdem erfüllt ist. Sie können die Backtick-Verknüpfung von Python 2 verwenden str/repr, um einige Bytes zu rasieren. Es gibt auch viel nicht benötigtes Leerzeichen hier.
FlipTack

Sie können auch Boolesche Werte als Ganzzahlwerte verwenden: Fügt h+=g(str(k))1 hinzu, wenn True, 0, wenn False.
FlipTack

@ Flp.Tkc kannst du den Backtick-Trick erklären. Ich habe versucht, es zu verwenden und es warf einen Syntaxfehler
George

Tun (Graviszeichen) x(Graviszeichen) in Python 2 die gleiche repr(x)oder str(x)in Python 3 :)
FlipTack

@ Flp.Tkc, das nur in Pre-Python 3 funktioniert. Es wurde in 3.0
George

0

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.

0

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

0

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
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.