Numeri divisibili per la somma e il prodotto delle loro cifre


24

Prendi un numero intero positivo X. Questo numero fa parte della sequenza a cui siamo interessati se la somma di tutte le cifre di Xè un divisore di Xe se il prodotto di tutte le cifre di Xè un divisore di X.

Ad esempio, 135è un tale numero perché 1 + 3 + 5 = 9divide 135 = 9 * 15e 1 * 3 * 5 = 15che divide anche 135.

Questa è la sequenza A038186 nell'OEIS.

Il tuo compito: dato un numero intero N, genera il Nnumero intero positivo con tali proprietà.

Ingressi e uscite

  • I numeri possono essere 0-indexed o 1-indexed; si prega di indicare quale utilizzare la risposta.

  • L'input può essere preso STDINcome argomento di funzione o qualcosa di simile.

  • L'output può essere stampato STDOUT, restituito da una funzione o qualcosa di simile.

Casi test

I seguenti casi di test sono non 1indicizzati.

Input        Output

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

punteggio

Questo è , quindi vince la risposta più breve in byte.


sarebbe ok stampare ogni numero mentre lo calcoli verso n = infinito?
Blu,

@BlueEyedBeast No, devi inserire un input e restituire il numero corrispondente.
Fatalizza il

Quando si controlla 10, il prodotto delle sue cifre è 0 o 1?
george

2
@george è il suo prodotto 0.
Fatalizza il

Posso limitare arbitrariamente l'intervallo dell'input se il limite superiore dell'intervallo non fosse calcolato prima della morte per calore dell'universo?
cat

Risposte:


11

05AB1E , 13 12 byte

Grazie a Emigna per aver salvato un byte!

µNNSONSP‚ÖP½

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online!


µNNSONSP‚ÖP½funziona anche vero?
Emigna,

@Emigna Nice one! Grazie :)
Adnan,

5

Pyke, 14 byte (non competitivo) (1 indicizzato)

~1IY'sB]im%X)@

Provalo qui!

Mio Dio, quante nuove funzionalità.

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

Di cui non competitivi

  • una correzione in Icui verificherebbe solo se il primo oggetto nello stack fosse vero
  • digits - restituisce un elenco di cifre nel numero
  • @ utilizzato per ottenere l'ennesimo elemento di un elenco infinito

Di cui venivano utilizzati per la prima volta:

  • tutti i precedenti
  • liste infinite

Rimuovere gli ultimi 2 byte per ottenere tutti questi numeri.


4

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

Programma completo con funzione non golfata e casi di 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
    }
}

1
for(int x=0,c=0;;)ti fa risparmiare 1 byte.
raznagul,

4

Gelatina , 13 byte

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

1-based.
TryItOnline!

Come?

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 byte (0 indicizzato)

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

Spiegazione:

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

Elenchi infiniti ftw!


@joshua grazie, ma quelle parentesi sono necessarie per la precedenza. Inoltre, l'utilizzo di un simbolo strano anziché *significherebbe più byte.
Ven

Ho dimenticato di controllare se aveva una risposta Perl 6 prima di pubblicare. Inoltre vorrei (ha fatto) gestire i guasti usando //0nel grepblocco.
Brad Gilbert b2gills il

@ BradGilbertb2gills Non esitate a pubblicare una versione migliore! Non l'ho usato //0perché di solito è accettato in codegolf per stampare su stderr.
Ven

Era letteralmente esattamente lo stesso, tranne per//0
Brad Gilbert b2gills

3

In realtà , 20 byte

Implementazione ingenua della definizione della sequenza. Suggerimenti di golf benvenuti! Provalo 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

Meduse , 45 byte

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

Provalo online!

Spiegazione

Questo è di gran lunga il programma più elaborato (e anche il più lungo) che ho scritto finora in Jellyfish. Non ho idea se sarò in grado di scomporre in modo comprensibile, ma immagino che dovrò provare.

Jellyfish fornisce un operatore di iterazione abbastanza generale \, che aiuta molto a "trovare l'ennesimo qualcosa ". Una delle sue semantiche è "iterare una funzione su un valore finché una funzione di test separata non dà qualcosa di vero" (in effetti, la funzione di test riceve sia l'elemento corrente che l'ultimo, ma faremo solo guardare l'elemento corrente) . Possiamo usarlo per implementare una funzione "prossimo numero valido". Un altro sovraccarico di \è "iterare una funzione su un valore iniziale N volte". Possiamo usare la nostra funzione precedente e iterarla su 0N volte, dove N è l'input. Tutto ciò è impostato in modo abbastanza conciso con questa parte del codice:

p
\Ai
\&
>     0

(I motivi per cui 0, l'effettivo input per la funzione risultante, è finita lì sono un po 'complicati e non entrerò in essi qui.)

Il problema con tutto ciò è che non passeremo manualmente il valore corrente alla funzione di test. L' \operatore lo farà per noi. Quindi ora abbiamo costruire una singola funzione unaria (tramite composizioni, ganci, forchette e curry) che accetta un numero e ci dice se è un numero valido (cioè uno che è diviso per la somma delle cifre e il prodotto delle cifre). Questo è abbastanza banale quando non puoi fare riferimento all'argomento. Mai. È questa bellezza:

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

La (è una unario gancio , il che significa che chiama la funzione qui sotto ( f) sul suo ingresso (valore attuale x), e poi passa entrambi per la funzione di test a destra ( g), che è esso calcola g(f(x), x).

Nel nostro caso, f(x)è un'altra funzione composita che ottiene una coppia con il prodotto cifra e la somma cifre di x. Ciò significa gche sarà una funzione che ha tutti e tre i valori per verificare se xè valida.

Inizieremo esaminando come fcalcola la somma delle cifre e il prodotto della cifra. Questo è f:

 &~b
  10
 ( )/*
 /+

&è anche composizione (ma viceversa). ~sta eseguendo il curry, quindi 10~bdà una funzione che calcola le cifre decimali di un numero, e poiché lo stiamo passando &da destra, questa è la prima cosa che accadrà all'input x. Il resto utilizza questo elenco di cifre per calcolare la somma e il prodotto.

Per calcolare una somma, possiamo piegare l' aggiunta su di essa, che è /+. Allo stesso modo, per calcolare il prodotto con cui pieghiamo la moltiplicazione su di esso /*. Per combinare entrambi questi risultati in una coppia, usiamo una coppia di ganci (e ). La struttura di questo è:

()g
f

(Dove fe gsono rispettivamente prodotto e somma.) Proviamo a capire perché questo ci dà un paio di f(x)e g(x). Nota che l'hook destro )ha solo un argomento. In questo caso, si suppone che sia l'altro argomento ;che avvolge i suoi argomenti in una coppia. Inoltre, gli hook possono anche essere usati come funzioni binarie (come sarà il caso qui) nel qual caso applicano semplicemente la funzione interna solo a un argomento. Quindi davvero )su una singola funzione gdà una funzione che calcola [x, g(y)]. Usando questo in un gancio sinistro, insieme a f, otteniamo [f(x), g(y)]. Questo, a sua volta, viene utilizzato in un contesto unario, il che significa che in realtà viene chiamato con x == ye quindi finiamo con [f(x), g(x)]come richiesto. Uff.

Ciò lascia solo una cosa, che era la nostra precedente funzione di test g. Ricordiamo che verrà chiamato come g([p, s], x)dove xè ancora il valore di input corrente, pè il suo prodotto cifra ed sè la sua somma cifra. Questo è g:

  &]&|
  <*&d
    N

Per testare la divisibilità, useremo ovviamente il modulo, che si trova |in Jellyfish. Un po 'insolitamente, prende il suo operando di destra modulo il suo operando di sinistra, il che significa che gli argomenti gsono già nell'ordine giusto (funzioni aritmetiche come questa passano automaticamente sugli elenchi, quindi questo calcolerà i due moduli separati gratuitamente) . Il nostro numero è divisibile per prodotto e somma, se il risultato è una coppia di zeri. Per verificare se è così, trattiamo la coppia come un elenco di cifre di base 2 ( d). Il risultato è zero, solo quando entrambi gli elementi della coppia sono zero, quindi possiamo negare il risultato di questo ( N) per ottenere un valore veritiero se entrambi i valori dividono l'input. Si noti che |, deNsono semplicemente tutti composti insieme con una coppia di &s.

Sfortunatamente, questa non è la storia completa. Cosa succede se il prodotto con cifre è zero? Divisione e modulo per zero restituiscono entrambi zero in Meduse. Mentre questa può sembrare una convenzione un po 'strana, in realtà si rivela in qualche modo utile (perché non è necessario controllare lo zero prima di eseguire il modulo). Tuttavia, significa anche che possiamo ottenere un falso positivo, se la somma delle cifre divide l'input, ma il prodotto della cifra è zero (ad es. Input 10).

Possiamo risolvere questo problema moltiplicando il nostro risultato di divisibilità per il prodotto cifra (quindi se il prodotto cifra è zero trasformerà anche il nostro valore di verità in zero). Risulta più semplice moltiplicare il risultato di divisibilità con la coppia di prodotto e la somma, ed estrarre successivamente il risultato dal prodotto.

Per moltiplicare il risultato con la coppia, è necessario tornare a un valore precedente (la coppia). Questo viene fatto con un fork ( ]). Le forcelle sono un po 'come i ganci degli steroidi. Se si danno loro due funzioni fe g, rappresentano una funzione binaria che calcola f(a, g(a, b)). Nel nostro caso, aè la coppia prodotto / somma, bè il valore di input corrente, gè il nostro test di divisibilità ed fè la moltiplicazione. Quindi tutto questo calcola [p, s] * ([p, s] % x == [0, 0]).

Tutto ciò che rimane ora è estrarre il primo valore di questo, che è il valore finale della funzione di test utilizzata nell'iteratore. Questo è semplice come comporre ( &) il fork con la funzione head< , che restituisce il primo valore di un elenco.


Come creatore di Jellyfish, approvo questo messaggio. (Davvero,
perderei la

3

R, 132 115 byte

Nuova versione grazie ai bei commenti di @Billywob!

n=scan();b=i=0;while(i<n){b=b+1;d=strtoi(el(strsplit(c(b,""),"")));if(na.omit(c(!b%%sum(d)&!b%%prod(d),0)))i=i+1};b

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

Dato che R si comporta in modo strano con NAs, ho dovuto aggiungere l'intera ifelse(is.na(...))parte!
Oppure usana.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};bsalva alcuni byte: el(...)invece di [[1]], usando c(b,"")invece di paste(b), negando le espressioni logiche !invece di ==0e saltando le parentesi graffe ifsull'istruzione. La mia ipotesi è che ci dovrebbe essere un modo più semplice di gestire il NAproblema, ma non riesco a capire qualcosa di intelligente.
Billywob,

1
Si scopre che possiamo aggirarlo aggiungendo 0a all'espressione valutata ifnell'istruzione. Tuttavia, questo restituisce un avviso quando il prodotto non è uguale a 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 Grazie mille! non lo sapevo el(...)!
Frédéric,

2

Brachylog , 22 byte

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

Provalo online!

Spiegazione

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

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

2

Pyth, 18 byte

e.f!.xs%LZsM*FBsM`

Provalo online: dimostrazione

Spiegazione:

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

dimostrazione

Tende ad essere lento per valori più alti, quindi lo sto limitando a 20 qui.


2

Haskell, 94 85 72 71 byte

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

1-indicizzati.

Grazie a @Zgarb per aver salvato 13 byte!

Grazie a @nimi per aver salvato un byte!


(==)=<<map(gcd n)$[sum k,product k]dovrebbe salvare alcuni byte.
Zgarb,

E mentre lo stiamo facendo, [sum k,product k]può essere map($read.pure<$>show n)[sum,product].
Zgarb,

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

1

MATL , 21 byte

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

Lunga e inefficiente ...

Provalo online!

Come funziona

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

Questo si è rivelato un po 'come la risposta di @Arnauld, ma a quanto pare la ricorsione è più breve di 2 byte. Funziona in Chrome, anche se è molto lento su input superiori a circa 30 (50 richiede 6 secondi).


1

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 indicizzato, è necessario utilizzare un interprete Python con un limite di ricorsione piuttosto elevato.


1

Meraviglia, 33 byte

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

Zero indicizzati. Uso:

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

Spiegazione

Più leggibile:

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

Praticamente ottiene un elenco infinito di numeri divisibili per la sua somma e prodotto digitale filtrando un elenco infinito di numeri interi attraverso un predicato. Quindi l' nelemento th viene semplicemente estratto dall'elenco.


1

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)

Questa è una funzione anonima che accetta un numero intero e restituisce un numero intero. Per chiamarlo, dagli un nome. L'approccio è ovvio: controlla ogni numero fino a quando non abbiamo incontrato i ntermini della sequenza. Il allcontrollo è necessario per assicurarsi che non ci sia unDivisionError da %quando il prodotto delle cifre è 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

Provalo online! (include tutti i casi di test)


È possibile salvare due byte assegnando prod(d)a po qualcosa e quindi sostituendo all(d.>0)con p>0. E puoi salvarne un altro spostando i%sum(d)l'altro lato di 1ie p<1>i%sum(d).
Martin Ender,

1

C89, 381 226 195 170 169 byte

1 indicizzato (stesse risposte esatte della sfida).

Presuppone 4 byte (32 bit)int (la maggior parte delle architetture moderne) .

Credo sinceramente che questo non possa essere più breve.

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 funzione int g (int)perde memoria e accede alla memoria non inizializzata una volta per chiamata, ma non segfault e restituisce il numero giusto.

Programma completo che accetta input in unario ( ./prog $(seq 1 10)per 10) con ungolfed (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));
}

Vecchia risposta:

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

Questo probabilmente può essere giocato a golf di più.

Programma completo:

#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/… genera alcuni avvisi, ma è equivalente. Tuttavia, penso che vada bene usare inttutto, dato che è il tipo intero predefinito.
Dennis,

@Dennis Non sono abituato a omettere le intestazioni e ignorare gli avvisi al di fuori di C89, quindi gioco con tutti gli avvisi abilitati e come errori: P però riscriverò in C89.
cat

@Dennis Risolto: D
cat

1

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 e utilizzo:

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 byte

Nuova versione grazie a 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))

Nuovo codice, mi sono ricordato un modo di giocare a golf per il fattoriale

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

Il codice in sé non è molto simile al golf, più simile al golf a forza bruta

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) è una funzione che restituisce True se x soddisfa i criteri.


In futuro, utilizzare <1invece di ==0. Non è necessario il is Truepunto di un'istruzione if è verificare se la condizione è vera comunque. Puoi usare la scorciatoia per il backtick di Python 2 per str/reprradere alcuni byte. C'è anche un sacco di spazi bianchi non necessari qui.
FlipTack,

Inoltre, puoi usare i valori booleani come valori interi: h+=g(str(k))aggiunge 1 se Vero, 0 se Falso.
FlipTack,

@ Flp.Tkc puoi spiegare il trucco del backtick. Ho provato a usarlo e ha generato un errore di sintassi
george

Fare (backtick) x(backtick) in Python 2 è lo stesso repr(x)o str(x)in Python 3 :)
FlipTack

@ Flp.Tkc che funziona solo in pre Python 3. È stato rimosso in 3.0
george

0

PHP, 96 byte

Prende ncome argomento della riga di comando.

golfed

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

Soluzione iterativa. Riceve input $ned entra in un forloop purché $nnon sia zero. Ogni iterazione, sottraggiamo dal $nrisultato di una dichiarazione booleana, suddivisa di seguito:

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

Pertanto, solo se $a%(sum)e $a%(product)sono entrambi uguali a zero anche l'aggiunta sarà zero, e quindi il non booleano sarà vero e quindi$n verrà decrementato.

Una volta usciti dal loop (ovvero, abbiamo raggiunto l' ennesimo termine), semplicemente posizioniamo$a sulla pipeline e l'output è implicito.

Esempi

Nota: questo genera una serie di errori "Tentativo di divisione per zero" su STDERR, che viene ignorato per impostazione predefinita. Ho esplicitamente aggiunto un 2>$nullesempio nell'esempio seguente per ripulire l'output. È anche piuttosto lento una volta circa 30, e 50impiega circa 45 secondi sulla mia macchina.

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 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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.