Si vous avez déjà entendu parler des nombres premiers en classe de mathématiques, vous avez probablement dû, à un moment donné, déterminer si un nombre est premier. Vous avez probablement gâché pendant que vous les appreniez, par exemple, en prenant 39 pour un premier. Eh bien, ne vous inquiétez pas, car 39 est un semi-premier, c'est-à-dire qu'il est le produit de deux nombres premiers.

De même, nous pouvons définir un k- presque premier comme étant le produit de k nombres premiers. Par exemple, 40 est le 4e 4-presque premier; 40 = 5 * 2 * 2 * 2, le produit de 4 facteurs.

Votre tâche consiste à écrire un programme / une fonction qui accepte deux entiers n et k comme entrée et sortie / retourne le n ème k- presque premier nombre. Il s'agit d'un code-golf, donc le programme le plus court en octets l'emporte.

Cas de test

n, k => output
n, 1 => the nth prime number
1, 1 => 2
3, 1 => 5
1, 2 => 4
3, 2 => 9
5, 3 => 27

Divers

Vous devez générer vous-même les nombres premiers par tout autre moyen qu'un simple formulaire fermé, si un tel formulaire fermé existe.

Pyth, 9 octets

e.fqlPZQE

Explication

          - autoassign Q = eval(input())
     PZ   -      prime_factors(Z) 
    l     -     len(^)
   q   Q  -    ^ == Q
 .f     E -  first eval(input()) of (^ for Z in range(inf))
e         - ^[-1]

Essayez-le ici!

Ou essayez une suite de tests!

Brachylog , 9 octets

Battre @sundar en utilisant deux fois moins d'octets

{~l~ḋ}ᶠ⁽t

Explication

                    --  Input like [n,k]
{    }ᶠ⁽            --      Find the first n values which
   ~ḋ               --          have a prime decomposition
 ~l                 --          of length k
        t           --      and take the last one

Essayez-le en ligne!

Pyke (commit 29), 8 octets (non compétitif)

.fPlQq)e

Explication:

         - autoassign Q = eval_or_not(input())
.f    )  - First eval_or_not(input) of (^ for i in range(inf))
  P      -    prime_factors(i)
   l     -   len(^)
     q   -  ^==V
    Q    -   Q
       e - ^[-1]

Julia, 84 78 59 57 octets

f(n,k,i=1)=n>0?f(n-(sum(values(factor(i)))==k),k,i+1):i-1

Il s'agit d'une fonction récursive qui accepte deux entiers et renvoie un entier. L'approche ici consiste à comparer la somme des exposants de la factorisation principale k.

Non golfé:

function f(n, k, i=1)
    # We initialize a counter i as a function argument.

    # Recurse while we've encountered fewer than n k-almost primes
    if n > 0
        # If the sum of the exponents in the prime factorization of i is
        # equal to k, there are k prime factors of i. We subtract a boolean
        # from n, which is implicitly cast to an integer, which will
        # decrement n if i is k-almost prime and leave it as is otherwise.
        return f(n - (sum(values(factor(i))) == k), k, i + 1)
    else
        # Otherwise we return i-1 (i will have been incremented one too
        # many times, hence the -1)
        return i - 1
    end
end

Gelée, 9 octets

ÆfL=³
ç#Ṫ

Essayez-le en ligne!

Comment ça marche

Ç#Ṫ    Main link. Left input: k. Right input: n.

Ç      Apply the helper link to k, k + 1, k + 2, ... until...
 #       n matches are found.
  Ṫ    Retrieve the last match.


ÆfL=³  Helper link. Left argument: k (iterator)

Æf     Yield the prime factors of k.
  L    Compute the length of the list, i.e., the number of prime factors.
   =³  Compare the result with k (left input).

Brachylog , 18 octets

,1{hH&t<NḋlH;N}ⁱ⁽t

Essayez-le en ligne!

                      Implicit input, say [5, 3]
,1                    Append 1 to the input list. [5, 3, 1]
  {           }ⁱ⁽     Repeat this predicate the number of times given by
                        the first element of the list (5),
                        on the rest of the list [3, 1]
   hH&                Let's call the first element H
      t<N             There is a number N greater than the second element
         ḋ            Whose prime factorization's
          l           length
           H          is equal to H
            ;N        Then, pair that N with H and let that be input for
                      the next iteration
                 t    At the end of iterations, take the last N
                      This is implicitly the output

Mathematica, 56 51 octets

Last@Select[Range[2^##],PrimeOmega@#==n&/.n->#2,#]&

Attention: c'est théorique. Ne pas exécuter pour des valeurs> 4. Remplacez 2 ^ ## par une expression plus efficace.

Mathematica, 53 49 octets

Cases[Range[2^(#2+#)],x_/;PrimeOmega@x==#2][[#]]&

Génère une liste d'entiers basée sur une limite supérieure lâche. PrimeOmegacompte les facteurs premiers avec multiplicités, le k -presque premier Casessont prises dans la liste, et le n ième membre de ce sous - ensemble est retourné.

Haskell, 88 octets

Peut probablement être joué au golf beaucoup plus, car je suis encore un débutant à Haskell. La fonction qrenvoie le nombre de facteurs de son argument et l' futilise pour obtenir l' nthélément d'une liste composée de tous les nombres qui ont des kfacteurs.

q n|n<2=0|1>0=1+q(div n ([x|x<-[2..],mod n x<1]!!0))
f n k=filter(\m->q m==k)[1..]!!n-1

MATL, 14 octets

:YqiZ^!XpSu1G)

Essayez-le sur MATL en ligne

:               % Take first input n implicitly, make range 1 to n
 Yq             % Get corresponding prime numbers (1st prime to nth prime)
   i            % Take the second input k
    Z^          % Take the k-th cartesian power of the primes list 
                % (Getting all combinations of k primes)
      !Xp       % Multiply each combination (2*2*2, 2*2*3, 2*2*5, ...)
         Su     % Sort and unique
           1G)  % Take the n-th element of the result

Python 3, 100 octets

Il s'agit d'une fonction de force brute très simple. Il vérifie chaque nombre à partir de 2 avec sympyla factorintfonction de jusqu'à ce qu'il ait trouvé n kpresque des nombres premiers, auquel cas la fonction renvoie le nth de ceux-ci.

import sympy
def a(n,k):
 z=1;c=0
 while c<n:z+=1;c+=(sum(sympy.factorint(z).values())==k)
 return z

Non golfé:

J'utilise sum(factorint(a).values())car factorintretourne un dictionnaire de factor: exponentpaires. Saisir les valeurs du dictionnaire (les exposants) et les additionner me dit combien il y a de facteurs premiers et donc ce qu'est kce- kpresque premier.

from sympy import factorint
def almost(n, k):
    z = 1
    count = 0
    while count < n: 
        z += 1
        if sum(factorint(a).values()) == k:
            count += 1
    return z

Python 2 , 76 octets

f=lambda n,k,p=2,c=0:c==k if p>n else f(n,k,p+1,c)if n%p else f(n/p,k,p,c+1)

Essayez-le en ligne!