Un nombre secondaire est un entier positif dont les facteurs premiers (sans multiplicité) sont tous inférieurs ou égaux à sa racine carrée. 4est un nombre secondaire, car son seul facteur premier est 2égal à sa racine carrée. Cependant, ce 15n’est pas un nombre secondaire, car il a 5pour facteur principal, qui est supérieur à sa racine carrée ( ~ 3.9). Parce que tous les nombres premiers ont eux-mêmes des facteurs premiers, aucun nombre premier n'est un nombre secondaire. Les premiers numéros secondaires sont les suivants:

1, 4, 8, 9, 12, 16, 18, 24, 25, 27, 30, 32, 36, 40, 45, 48, 49, 50, 54, 56

Un nombre tertiaire est défini de la même façon, sauf que tous les facteurs premiers doivent être inférieurs ou égaux à sa racine cubique. Les premiers numéros tertiaires sont les suivants:

1, 8, 16, 27, 32, 36, 48, 54, 64, 72, 81, 96, 108, 125, 128, 135, 144, 150, 160, 162

En général, un nombre n-aire est un nombre dont les facteurs premiers sont tous inférieurs ou égaux à sa nième racine. Ainsi, un entier positif $x$ est un nnombre -ary si et seulement si chacun de ses facteurs premiers $p$ satisfait $p^n ≤ x$ . Ainsi, les nombres primaires sont tous des entiers positifs (tous les facteurs premiers inférieurs ou égaux à eux-mêmes), les nombres du quartième siècle ont tous leurs facteurs premiers inférieurs ou égaux à leur quatrième racine, et ainsi de suite.

Le défi

Étant donné les entiers ket en ntant qu'entrées, donne le numéro kth n-ary. kpeut être zéro ou un index (votre choix) et nsera toujours positif.

Exemples

Ce sont les 20 premiers éléments de chaque séquence, jusqu'à 10 nombres:

Primary: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20
Secondary: 1, 4, 8, 9, 12, 16, 18, 24, 25, 27, 30, 32, 36, 40, 45, 48, 49, 50, 54, 56
Tertiary: 1, 8, 16, 27, 32, 36, 48, 54, 64, 72, 81, 96, 108, 125, 128, 135, 144, 150, 160, 162
Quarternary: 1, 16, 32, 64, 81, 96, 108, 128, 144, 162, 192, 216, 243, 256, 288, 324, 384, 432, 486, 512
5-ary: 1, 32, 64, 128, 243, 256, 288, 324, 384, 432, 486, 512, 576, 648, 729, 768, 864, 972, 1024, 1152
6-ary: 1, 64, 128, 256, 512, 729, 768, 864, 972, 1024, 1152, 1296, 1458, 1536, 1728, 1944, 2048, 2187, 2304, 2592
7-ary: 1, 128, 256, 512, 1024, 2048, 2187, 2304, 2592, 2916, 3072, 3456, 3888, 4096, 4374, 4608, 5184, 5832, 6144, 6561
8-ary: 1, 256, 512, 1024, 2048, 4096, 6561, 6912, 7776, 8192, 8748, 9216, 10368, 11664, 12288, 13122, 13824, 15552, 16384, 17496
9-ary: 1, 512, 1024, 2048, 4096, 8192, 16384, 19683, 20736, 23328, 24576, 26244, 27648, 31104, 32768, 34992, 36864, 39366, 41472, 46656
10-ary: 1, 1024, 2048, 4096, 8192, 16384, 32768, 59049, 62208, 65536, 69984, 73728, 78732, 82944, 93312, 98304, 104976, 110592, 118098, 124416

Gelée , 12 octets

Æf*³<‘Ạ
1Ç#Ṫ

Prend n et k (un index) comme arguments de ligne de commande.

Essayez-le en ligne!

Comment ça marche

1Ç#Ṫ     Main link. Left argument: n. Right argument: k

1        Set the return value to 1.
 Ç#      Execute the helper link above for r = 1, 2, 3, ... until k of them return
         a truthy value. Yield the list of all k matches.
   Ṫ     Tail; extract the last match.


Æf*³<‘Ạ  Helper link. Argument: r

Æf       Compute all prime factors of r.
  *³     Elevate them to the n-th power.
    <‘   Compare all powers with r + 1.
      Ạ  All; return 1 if all comparisons were true, 0 if one or more were not.

Brachylog , 21 octets

:[1]cyt
,1|,.$ph:?^<=

Essayez-le en ligne!

Cette réponse est un indexé.

Explication

Input: [N:K]

:[1]cy              Retrieve the first K valid outputs of the predicate below with N as input
      t             Output is the last one

,1                  Output = 1
  |                 Or
   ,.$ph            Take the biggest prime factor of the Output
        :?^<=       Its Nth power is less than the Output

JavaScript (ES7), 95 90 octets

Assez rapide mais malheureusement limité par le nombre maximal de récursions.

f=(k,n,i=1)=>(F=(i,d)=>i-1?d>1?i%d?F(i,d-1):F(i/d,x):1:--k)(i,x=++i**(1/n)|0)?f(k,n,i):i-1

Comment ça marche

Plutôt que de factoriser un entier i et de vérifier que tous ses facteurs premiers sont inférieurs ou égaux à x = floor (i ^{1 / n} ) , nous essayons de valider directement cette dernière hypothèse. C'est le but de la fonction interne F () :

F = (i, d) =>         // given an integer i and a divisor d:
  i - 1 ?             //   if the initial integer is not yet fully factored
    d > 1 ?           //     if d is still a valid candidate
      i % d ?         //       if d is not a divisor of i
        F(i, d - 1)   //         try again with d-1 
      :               //       else
        F(i / d, x)   //         try to factor i/d
    :                 //     else
      1               //       failed: yield 1
  :                   //   else
    --k               //     success: decrement k

Nous vérifions si un entier d dans [2 ... i ^{1 / n} ] divise i . Sinon, l'hypothèse n'est pas valide et nous retournons 1 . Si oui, on répète récursivement le processus sur i = i / d jusqu'à ce qu'il échoue ou que l'entier initial soit entièrement factorisé ( i == 1 ), auquel cas on décrémente k . À son tour, la fonction externe f () est appelée récursivement jusqu'à ce que k == 0 .

Remarque: En raison d'erreurs d'arrondi en virgule flottante telles que 125**(1/3) == 4.9999…, la valeur réelle calculée pour x est floor ((i + 1) ^{1 / n} ) .

Démo

(Voici une version ES6 de 97 octets pour une meilleure compatibilité.)

f=(k,n,i=1)=>(F=(i,d)=>i-1?d>1?i%d?F(i,d-1):F(i/d,x):1:--k)(i,x=Math.pow(++i,1/n)|0)?f(k,n,i):i-1

console.log(f(17, 3)); // 144
console.log(f(13, 4)); // 243
console.log(f(4, 10)); // 4096

JavaScript (ES7), 93 79 octets

f=(k,n,g=(i,j=2)=>i<2?--k?g(++m):m:j**n>m?g(++m):i%j?g(i,j+1):g(i/j,j))=>g(m=1)

Je ne comprenais pas la réponse de Arnauld, alors j’écrivis la mienne. Edit: 14 octets enregistrés avec l’aide de @ETHproductions. Ungolfed:

function ary(k, n) {
    for (var c = 1;; c++) {
        var m = c;
        for (var i = 2; m > 1 && i ** n <= c; i++)
            while (m % i == 0) m /= i;
        if (m == 1 && --k == 0) return c;
    }
}

Haskell, 86 octets

m#n=(0:1:filter(\k->last[n|n<-[2..k],all((>0).rem n)[2..n-1],k`rem`n<1]^n<=k)[2..])!!m

Explication:

( %%%%dénote le code de la ligne ci-dessus)

    [n|n<-[2..k],all((>0).rem n)[2..n-1],k`rem`n<1]  -- generates all prime factors of k
    last%%%%^n<=k                                    -- checks whether k is n-ary
    (0:1:filter(\k->%%%%)[2..])!!m                   -- generates all n-ary nubmers and picks the m-th
     m#n=%%%%                                        -- assignment to the function #

Pyth, 13 octets

e.f.AgL@ZQPZE

Essayez-le en ligne.

Fonctionne vraiment comme la solution Jelly.

e.f.AgL@ZQPZE
                 Implicit: read n into Q.
            E    Read k.
 .f              Find the first k integers >= 1 for which
   .A            all
          P      prime factors of
           Z     the number
     gL          are at most
         Q       the n'th
       @         root of
        Z        the number.
e                Take the last one.

Perl 6, 88 octets

->\k,\n{sub f(\n,\d){n-1??n%%d??f n/d,d!!f n,d+1!!d};(1,|grep {$_>=f($_,2)**n},2..*)[k]}

Mon intuition accidentelle est que vous n'avez pas besoin de regarder tous les facteurs de n , mais uniquement le plus important, qui est calculé par la fonction interne f. Malheureusement, il souffle la pile avec des entrées plus grandes.

La robustesse peut être améliorée en ajoutant un test de primalité, utilisant la is-primeméthode intégrée sur Ints, pour un coût de plusieurs caractères supplémentaires.

Coque , 10 octets

!fS≤ȯ^⁰→pN

Essayez-le en ligne!

Explication

Il m'a fallu un certain temps pour comprendre comment utiliser →sur la liste vide les retours 1au lieu de ceux -Infpour ▲lesquels il reste 1(sinon cela coûterait 2 octets pour l'ajouter à nouveau):

!fS≤(^⁰→p)N  -- input n as ⁰ and k implicit, for example: 4 3
!f        N  -- filter the natural numbers by the following predicate (example on 16):
  S≤(    )   --   is the following less than the element (16) itself?
        p    --   ..prime factors (in increasing order): [2]
       →     --   ..last element/maximum: 2
     ^⁰      --   ..to the power of n: 16
             --   16 ≤ 16: yes
             -- [1,16,32,64,81..
!            -- get the k'th element: 32

R, 93 octets

f=function(k,n){x='if'(k,f(k-1,n)+1,1);while(!all(numbers::primeFactors(x)<=x^(1/n)))x=x+1;x}

Zéro indexé.

C'est une fonction récursive qui ne fait que continuer jusqu'à trouver le prochain nombre en ligne. Utilise pour numbersemballer pour trouver les facteurs premiers.

MATL, 21 octets

x~`@YflG^@>~A+t2G<}x@

Cette solution utilise une indexation à base unique et les entrées sont net k, respectivement.

Essayez-le en ligne!

Explication

x       % Implicitly grab the first input and delete it
~       % Implicitly grab the second input and make it FALSE (0) (this is the counter)
`       % Beginning of the do-while loop
  @Yf   % Compute the prime factors of the current loop index
  1G^   % Raise them to the power of the first input
  @>    % Determine if each value in the array is greater than the current index
  ~A    % Yield a 0 if any of them were and a 1 if they weren't
  +     % Add this to the counter (increments only for positive cases)
  t2G<  % Determine if we have reached a length specified by the second input
}       % After we exit the loop (finally), ...
x@      % Delete the counter and push the current loop index to the stack
        % Implicitly display the result

Brachylog v2 , 16 octets

{∧.ḋ,1⌉;?^≤}ᶠ⁽t

Essayez-le en ligne!

Crédit à la solution Jelly de Dennis m'avoir fait réfléchir dans la bonne direction.

Explication

Voici une version légèrement non-golfée, plus facile à analyser:

↰₁ᶠ⁽t
∧.ḋ,1⌉;?^≤

Prédicat auxiliaire (ligne 2): l'entrée est l'exposant n , la sortie n'est pas contrainte:

∧           Break implicit unification
 .ḋ         Get the prime factors of the output
   ,1       Append 1 (necessary because 1 has no prime factors and you can't take
            the max of an empty list)
     ⌉      Max (largest prime factor, or 1 if the output is 1)
      ;?    Pair that factor with the input (n)
        ^   Take factor to the power of n
         ≤  Verify that the result is less than or equal to the output

Prédicat principal (ligne 1): l'entrée est une liste contenant l'indice k (basé sur 1) et l'exposant n ; la sortie n'est pas contrainte:

  ᶠ⁽   Find the first k outputs of
↰₁     calling the helper predicate with n as input
    t  Get the last (i.e. kth) one

APL (NARS), 53 caractères, 106 octets

r←a f w;c
c←0⋄r←1
→3×⍳∼∧/(πr)≤a√r⋄→0×⍳w≤c+←1
r+←1⋄→2

tester:

  1 f¨1..20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 
  2 f¨1..20
1 4 8 9 12 16 18 24 25 27 30 32 36 40 45 48 49 50 54 56 
  3 f¨1..20
1 8 16 27 32 36 48 54 64 72 81 96 108 125 128 135 144 150 160 162 
  4 f¨1..20
1 16 32 64 81 96 108 128 144 162 192 216 243 256 288 324 384 432 486 512 
  10 f¨1..20
1 1024 2048 4096 8192 16384 32768 59049 62208 65536 69984 73728 78732 82944 93312 98304 104976 110592 118098 124416 

Python 2 , 114 octets

f=lambda K,n,i=1:K and f(K-all(j**n<=i for j in range(1,i+1)if i%j==0and all(j%k for k in range(2,j))),n,i+1)or~-i

Essayez-le en ligne!

Fonction 1-indexée.

Japt , 14 octets

Prend ncomme première entrée et k(indexé 1) comme seconde.

@_k e§Vq}aXÄ}g

L'essayer