Prenez un entier positif X. Ce nombre fait partie de la séquence qui nous intéresse si la somme de tous les chiffres de Xest un diviseur de X, et si le produit de tous les chiffres de Xest un diviseur de X.

Par exemple, 135est un tel nombre car 1 + 3 + 5 = 9qui divise 135 = 9 * 15et 1 * 3 * 5 = 15qui divise également 135.

Il s'agit de la séquence A038186 dans l'OEIS.

Votre tâche: étant donné un entier N, sortez le Ne entier positif avec de telles propriétés.

Entrées et sorties

• Les nombres peuvent être 0-indexés ou 1-indexés; veuillez indiquer celle que votre réponse utilise.

• L'entrée peut être prise en compte STDIN, comme argument de fonction, ou quelque chose de similaire.

• La sortie peut être imprimée STDOUT, renvoyée par une fonction ou quelque chose de similaire.

Cas de test

Les cas de test ci-dessous sont 1indexés.

Input        Output

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

Notation

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

05AB1E , 13 12 octets

Merci à Emigna d' avoir enregistré un octet!

µNNSONSP‚ÖP½

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Pyke, 14 octets (non compétitif) (1 indexé)

~1IY'sB]im%X)@

Essayez-le ici!

Mon dieu ce que beaucoup de nouvelles fonctionnalités.

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

Dont non compétitifs

• un bug dans Ilequel il ne vérifierait que si le premier élément de la pile était véridique
• digits - retourne une liste de chiffres dans le numéro
• @ utilisé pour obtenir le nième élément d'une liste infinie

Dont étaient utilisés pour la première fois:

• Tout ce qui précède
• listes infinies

Supprimez les 2 derniers octets pour obtenir tous ces nombres.

C #, 118 octets

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

Programme complet avec fonction non golfée et cas de test:

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

Gelée , 13 octets

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

1 basé.
TryItOnline!

Comment?

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 octets (indexé 0)

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

Explication:

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

Listes infinies ftw!

En fait , 20 octets

Implémentation naïve de la définition de séquence. Suggestions de golf bienvenues! Essayez-le en ligne!

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.

Méduse , 45 octets

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

Essayez-le en ligne!

Explication

C'est de loin le programme le plus élaboré (et aussi le plus long) que j'ai écrit dans Jellyfish jusqu'à présent. Je ne sais pas si je serai en mesure de décomposer cela d'une manière compréhensible, mais je suppose que je devrai essayer.

Jellyfish fournit un opérateur d'itération assez général \, ce qui aide beaucoup à «trouver le Nth quelque chose ». L'une de ses sémantiques est "itérer une fonction sur une valeur jusqu'à ce qu'une fonction de test distincte donne quelque chose de vrai" (en fait, la fonction de test reçoit à la fois le courant et le dernier élément, mais nous ne ferons que regarder l'élément actuel) . Nous pouvons l'utiliser pour implémenter une fonction "prochain numéro valide". Une autre surcharge de \"itère une fonction sur une valeur de départ N fois". Nous pouvons utiliser notre fonction précédente et l'itérer sur 0N fois, où N est l'entrée. Tout cela est configuré de manière assez concise avec cette partie du code:

p
\Ai
\&
>     0

(Les raisons pour lesquelles 0l'entrée réelle de la fonction résultante est là-bas sont un peu compliquées et je ne les aborderai pas ici.)

Le problème avec tout cela est que nous ne transmettrons pas la valeur actuelle à la fonction de test manuellement. L' \opérateur le fera pour nous. Nous avons donc maintenant construire une seule fonction unaire (via les compositions, les crochets, les fourchettes et le curry) qui prend un nombre et nous dit si c'est un nombre valide (c'est-à-dire qui est divisé par sa somme de chiffres et son produit de chiffres). Ceci est assez non trivial lorsque vous ne pouvez pas vous référer à l'argument. Déjà. C'est cette beauté:

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

Le (est un crochet unaire , ce qui signifie qu'il appelle la fonction ci-dessous ( f) sur son entrée (la valeur actuelle x), puis passe les deux à la fonction de test à droite ( g), c'est-à-dire qu'il calcule g(f(x), x).

Dans notre cas, f(x)est une autre fonction composite qui obtient une paire avec le produit numérique et la somme numérique de x. Cela signifie que gsera une fonction qui a les trois valeurs pour vérifier si elle xest valide.

Nous allons commencer par regarder comment fcalcule la somme des chiffres et le produit des chiffres. C’est f:

 &~b
  10
 ( )/*
 /+

&c'est aussi la composition (mais l'inverse). ~currying 10~bdonne donc une fonction qui calcule les chiffres décimaux d'un nombre, et puisque nous passons cela à &droite, c'est la première chose qui arrivera à l'entrée x. Le reste utilise cette liste de chiffres pour calculer leur somme et leur produit.

Pour calculer une somme, nous pouvons plier l' addition sur elle, ce qui est /+. De même, pour calculer le produit, nous multiplions la multiplication par dessus /*. Pour combiner ces deux résultats en une paire, nous utilisons une paire de crochets, (et ). La structure de ceci est:

()g
f

(Où fet gsont le produit et la somme, respectivement.) Essayons de comprendre pourquoi cela nous donne une paire de f(x)et g(x). Notez que le crochet droit )n'a qu'un seul argument. Dans ce cas, l'autre argument est supposé être celui ;qui encapsule ses arguments dans une paire. De plus, les hooks peuvent également être utilisés comme fonctions binaires (ce qui sera le cas ici), auquel cas ils n'appliquent la fonction interne qu'à un seul argument. Donc vraiment )sur une seule fonction gdonne une fonction qui calcule [x, g(y)]. En utilisant cela dans un crochet gauche, avec f, nous obtenons [f(x), g(y)]. Ceci, à son tour, est utilisé dans un contexte unaire, ce qui signifie qu'il est en fait appelé avec x == yet nous nous retrouvons donc [f(x), g(x)]comme requis. Phew.

Cela ne laisse qu'une seule chose, qui était notre fonction de test précédente g. Rappelez-vous qu'il sera appelé comme g([p, s], x)où xest toujours la valeur d'entrée actuelle, pest son produit numérique et ssa somme numérique. C’est g:

  &]&|
  <*&d
    N

Pour tester la divisibilité, nous utiliserons évidemment le modulo, qui est |dans Jellyfish. Un peu inhabituellement, il prend son opérande de droite modulo son opérande de gauche, ce qui signifie que les arguments à gsont déjà dans le bon ordre (les fonctions arithmétiques comme celle- ci passent automatiquement sur les listes, donc cela calculera les deux modules séparés gratuitement) . Notre nombre est divisible par le produit et la somme, si le résultat est une paire de zéros. Pour vérifier si c'est le cas, nous traitons la paire comme une liste de chiffres en base 2 ( d). Le résultat de ceci est zéro, uniquement lorsque les deux éléments de la paire sont nuls, nous pouvons donc annuler le résultat de this ( N) pour obtenir une valeur vraie pour savoir si les deux valeurs divisent l'entrée. Notez que |, detNsont simplement tous composés avec une paire de &s.

Malheureusement, ce n'est pas toute l'histoire. Et si le produit numérique est nul? La division et le modulo par zéro renvoient tous les deux zéro dans les méduses. Bien que cela puisse sembler une convention quelque peu étrange, cela s'avère en fait quelque peu utile (car nous n'avons pas besoin de vérifier zéro avant de faire le modulo). Cependant, cela signifie également que nous pouvons obtenir un faux positif, si la somme des chiffres divise l'entrée, mais que le produit numérique est zéro (par exemple, l'entrée 10).

Nous pouvons résoudre ce problème en multipliant notre résultat de divisibilité par le produit numérique (donc si le produit numérique est nul, cela transformera également notre valeur véridique en zéro). Il s'avère plus simple de multiplier le résultat de divisibilité par la paire de produit et de somme, et d'extraire ensuite le résultat du produit.

Pour multiplier le résultat avec la paire, nous devons en quelque sorte revenir à une valeur antérieure (la paire). Cela se fait avec un fork ( ]). Les fourchettes sont un peu comme des crochets sur les stéroïdes. Si vous leur donnez deux fonctions fet g, elles représentent une fonction binaire qui calcule f(a, g(a, b)). Dans notre cas, aest la paire produit / somme, best la valeur d'entrée actuelle, gest notre test de divisibilité et fest la multiplication. Donc, tout cela calcule [p, s] * ([p, s] % x == [0, 0]).

Il ne reste plus qu'à en extraire la première valeur, qui est la valeur finale de la fonction de test utilisée dans l'itérateur. C'est aussi simple que de composer ( &) la fourche avec la fonction head< , qui retourne la première valeur d'une liste.

R, 132 115 octets

Nouvelle version grâce à @Billywob de beaux commentaires!

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

Non golfé:

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

Puisque R se comporte étrangement avec NAs, j'ai dû ajouter la ifelse(is.na(...))partie entière !
Ou utiliserna.omit(...)

Brachylog , 22 octets

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

Essayez-le en ligne!

Explication

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

Moins golfé

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 octets

e.f!.xs%LZsM*FBsM`

Essayez-le en ligne: Démonstration

Explication:

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 octets

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

Démo

Il a tendance à être lent pour des valeurs plus élevées, donc je le limite à 20 ici.

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 octets

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

1 indexé.

Merci à @Zgarb pour avoir économisé 13 octets!

Merci à @nimi d'avoir enregistré un octet!

MATL , 21 octets

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

Long et inefficace ...

Essayez-le en ligne!

Comment ça marche

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

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

Cela s'est avéré un peu comme la réponse de @ Arnauld, mais la récursivité est apparemment plus courte de 2 octets. Fonctionne dans Chrome, bien qu'il soit très lent sur des entrées supérieures à 30 environ (50 prend 6 secondes).

Python 2, 122 110 octets

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 indexé, vous devez utiliser un interpréteur Python avec une limite de récursivité assez élevée.

Wonder, 33 octets

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

Zéro indexé. Usage:

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

Explication

Plus lisible:

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

Obtient fondamentalement une liste infinie de nombres divisibles par sa somme numérique et son produit en filtrant une liste infinie de nombres entiers à travers un prédicat. Ensuite, le ne élément est simplement choisi dans la liste.

Julia, 81 octets

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)

Il s'agit d'une fonction anonyme qui accepte un entier et renvoie un entier. Pour l'appeler, donnez-lui un nom. L'approche est la plus évidente: vérifiez chaque nombre jusqu'à ce que nous ayons rencontré les ntermes de la séquence. La allvérification est nécessaire pour s'assurer que nous n'obtenons pas DivisionErrorde %lorsque le produit des chiffres est 0.

Non golfé:

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

Essayez-le en ligne! (inclut tous les cas de test)

C89, 381 226 195 170 169 octets

1 indexé (mêmes réponses exactes que dans le défi).

Suppose 4 octets (32 bits)int (architectures les plus modernes) .

Je crois sincèrement que cela ne peut pas être plus court.

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

La fonction int g (int)fuit la mémoire et accède à la mémoire non initialisée une fois par appel, mais ne fait pas de défaut et renvoie le bon numéro.

Programme complet qui prend en entrée unaire ( ./prog $(seq 1 10)pour 10) avec non golfé (un peu):

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

Ancienne réponse:

C99, 381 octets

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

Cela peut probablement être joué plus.

Programme complet:

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

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

Non golfé et utilisation:

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 octets

Nouvelle version grâce à 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))

Nouveau code, je me suis souvenu d'une façon golfique de faire le factoriel

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

Le code lui-même n'est pas très semblable au golf, plus comme le golf par force brute

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) est une fonction qui renvoie True si x correspond aux critères.

PHP, 96 octets

Prend ncomme argument de ligne de commande.

Golfé

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

Non golfé

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 octets

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

Solution itérative. Prend l'entrée $net entre dans une forboucle tant qu'elle $nn'est pas nulle. À chaque itération, nous soustrayons $nle résultat d'une instruction booléenne, détaillée ci-dessous:

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

Ainsi, seulement si $a%(sum)et $a%(product)sont tous deux égaux à zéro, l'addition sera également nulle, et donc le booléen-non sera vrai et sera donc $ndécrémenté.

Une fois que nous sortons de la boucle (c'est-à-dire que nous frappons le nième terme), nous plaçons simplement $asur le pipeline, et la sortie est implicite.

Exemples

Remarque: Cela envoie un tas d'erreurs "Tentative de division par zéro" à STDERR, qui est ignoré par défaut. J'ai explicitement ajouté un 2>$nullà l'exemple ci-dessous pour nettoyer la sortie. Il est également assez lent une fois qu'il arrive à peu près à peu près 30, et 50prend environ 45 secondes sur ma machine.

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 octets

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