Si un entier positif a (strictement) moins de facteurs premiers (sans compter les multiplicités) que son successeur et son prédécesseur, nous l'appellerons un nombre pauvre en facteurs .$N > 2$

En d' autres termes, et , où est le nombre de facteurs premiers uniques de .$\omega(N) < \omega(N - 1)$$\omega(N) < \omega(N + 1)$$\omega(N)$$N$

Tâche

Vous pouvez choisir parmi les formats d'E / S suivants:

• Prenez un entier et sortez le nombre pauvre en facteur. Si vous choisissez celui-ci, peut être indexé 0 ou 1.$N$$N^{\text{th}}$$N$
• Prenez un entier positif et sortez les premiers nombres pauvres en facteurs.$N$$N$
• Imprimez la séquence indéfiniment.

Vous pouvez prendre des entrées et fournir des sorties via n'importe quelle méthode standard , dans n'importe quel langage de programmation , tout en prenant note que ces failles sont interdites par défaut. C'est le golf de code, donc la soumission la plus courte qui respecte les règles l'emporte.

Je n'inclurai pas de cas de test séparés, car les méthodes de compétition sont différentes, mais vous pouvez vous référer aux 100 premiers termes de cette séquence, qui est OEIS A101934 :

11, 13, 19, 23, 25, 27, 29, 37, 41, 43, 47, 49, 53, 59, 61, 64, 67, 71, 73, 79, 81, 83, 89, 97, 101, 103, 107, 109, 113, 121, 125, 131, 137, 139, 149, 151, 155, 157, 163, 167, 169, 173, 179, 181, 191, 193, 197, 199, 211, 221, 223, 227, 229, 233, 239, 241, 243, 251, 259, 263, 265, 269, 271, 277, 281, 283, 289, 293, 307, 309, 311, 313, 317, 331, 337, 341, 343, 347, 349, 353, 359, 361, 365, 367, 371, 373, 379, 383, 389, 397, 401, 407, 409, 419, 421, 431, 433, 439, 441, 443

Par exemple, se produit dans cette séquence parce que (5), \ omega (26) = 2 (2 et 13) et \ omega (24) = 2 (2 et 3), donc \ omega (25) <\ omega (24) et \ omega (25) <\ omega (26) .ω ( 25 ) = 1 ω ( 26 ) = 2 ω ( 24 ) = 2 ω ( 25 ) < ω ( 24 ) ω ( 25 ) < ω ( 26 $25$$\omega(25) = 1$$\omega(26) = 2$$\omega(24) = 2$$\omega(25) < \omega(24)$$\omega(25) < \omega(26)$

Brachylog , 21 octets

⟨+₁≡-₁⟩{ḋdl}ᵐ⌋>~↰₂?ẉ⊥

Essayez-le en ligne!

Imprime à l'infini.

Explication

⟨+₁≡-₁⟩                  Fork: The output of the fork is [Input + 1, Input -1]
       {   }ᵐ            Map:
        ḋdl                (predicate 2) the output is the length of the prime decomposition
                           of the input with no duplicates
             ⌋           Take the minimum result of that map
              >          This minimum is bigger than…
               ~↰₂?      …the output of predicate 2 with Input as input
                  ?ẉ     Write Input followed by a new line if that's the case
                    ⊥    False: backtrack and try another value for Input

Gelée , 13 12 octets

Cr~ÆvÐṂN⁼Wø#

Imprime les n premiers nombres pauvres en facteurs.

Essayez-le en ligne!

Comment ça fonctionne

Cr~ÆvÐṂN⁼Wø#  Main link. No arguments.

          ø   Wrap the links to the left into a chain and begin a new chain.
           #  Read an integer n from STDIN and call the chain to the left with
              arguments k = 0, 1, 2, ... until n of them return a truthy value.
              Return those n values of k as an array.
C                 Complement; yield -k+1.
  ~               Bitwise NOT; yield -k-1.
 r                Range; yield [-k+1, -k, -k-1].
     ÐṂ           Yield those elements of [-k+1, -k, -k-1] for which the link to
                  the left returns the minimal value.
   Æv                 Count the number of unique prime factors.
                      Note that, for a negative argument, Æv counts -1 as well, and
                      0 is counted as a/the factor of 0. Negating the the arguments
                      eliminates the edge case 1 (no factors), which would be a
                      false positive otherwise.
                  For a factor-poor number, this yields [-k].
       N          Take the negatives of the resulting integers.
         W        Wrap; yield [k].
        ⁼         Test the results to both sides for equality.

Python 2 , 123 119 octets

q=lambda n:sum(n%i<all(i%j for j in range(2,i))for i in range(2,n+1))
i=2
while 1:
 i+=1
 if q(i-1)>q(i)<q(i+1):print i

Essayez-le en ligne!

MATL , 26 24 22 octets

`T@3:q+YFg!sdZSd0>?@QD

Imprime la séquence indéfiniment.

Essayez-le en ligne!

Explication

`         % Do...while loop
  T       %   Push true. Will be used as loop condition
  @       %   Push (1-based) iteration index, k 
  3:q     %   Push [1 2 3] minus 1, that is, [0 1 2]
  +       %   Add, element-wise. Gives [k k+1 k+2]
  YF      %   Exponents of prime-factor decomposition. Gives a 3-row matrix
  g       %   Convert to logical: non-zero numbers become 1
  !s      %   Transpose, sum of each column. Gives a row vector of 3 elements, 
          %   which are the number of unique prime factors of k, k+1 and k+2 
  d       %   Consecutive differences. Gives a row vector of 2 elements
  ZS      %   Sign: replaces each number by -1, 0 or 1
  d       %   Consecutive difference. Gives a single number
  0>      %   Is it positive?
  ?       %   If so
    @Q    %     Push k+1
    D     %     Display
          %   End (implicit)
          % End (implicit). The stack contains true, which (is consumed and)
          % causes an infinite loop

Husk , 22 octets

f(ΠtSM<←ṙ1mȯLup§…←→)tN

Imprime la séquence indéfiniment, essayez-la en ligne ou consultez le premier N !

Alternativement, §oΛ>←t pourrait être utilisé à la place de ΠtSM<←.

Explication

f(                  )tN  -- filter the tail of the naturals ([2,3…]) by:
  ΠtSM<←ṙ1m(Lup)§…←→     -- | takes a number as argument, example 11
                §…       -- | range of..
                  ←      -- | | the argument decremented (10)
                   →     -- | | to the argument incremented (12)
                         -- | : [10,11,12]
          m(   )         -- | map the following (example on 12) ..
              p          -- | | prime factors: [2,2,3]
             u           -- | | deduplicate: [2,3]
            L            -- | | length: 2
                         -- | : [2,1,2]
        ṙ1               -- | rotate by 1: [1,2,2]
    SM<                  -- | map the function (< X) over the list where X is ..
       ←                 -- | | the first element (1)
                         -- | : [0,1,1]
   t                     -- | tail: [1,1]
  Π                      -- | product: 1
                         -- : [11,13,19,23,25,27,29…

Pyth , 14 octets

.f!-.ml{Pb}tZh

Essayez-le ici!

C'était initialement une suggestion sur la réponse de Dopapp , mais ils m'ont dit de la poster séparément.

Comment ça fonctionne?

.f! -. ml {Pb} tZh | Programme complet. Prend l'entrée de STDIN, sort le premier N vers STDOUT.

.f | (var: Z) Affiche les N premières valeurs qui satisfont le prédicat.
          } tZh | Crée la liste [Z - 1, Z, Z + 1].
    .m | (var: b) Prenez les éléments avec une valeur de fonction minimale.
        Pb | Facteurs premiers de b.
      l {| Dédupliquez, obtenez la longueur.
               | Pour un nombre pauvre en facteurs, cela donne lui-même enveloppé dans un singleton.
   - | Retirez Z de cela.
  ! | Négation logique.

Haskell, 105 86 octets

Merci à @Wheat Wizard, @Bruce Forte et @Laikoni pour avoir économisé 19 octets.

[n|n<-[2..],d n<d(n-1),d n<d(n+1)] d x=[1|n<-[1..x],x`rem`n<1,all((>0).rem n)[2..n-1]]

Octave ,  87   83  79 octets

Merci à @Cows quack d'avoir enregistré un octet et merci à @Luis Mendo d'avoir enregistré trois six octets!

f=@(n)nnz(unique(factor(n)));n=9;while++n if[f(n-1) f(n+1)]>f(n)disp(n);end;end

Imprime la séquence indéfiniment.

Essayez-le en ligne!

73 octets avec interligne n =avant chaque valeur:

f=@(n)nnz(unique(factor(n)));n=9;while++n if[f(n-1) f(n+1)]>f(n)n end;end

Essayez-le en ligne!

05AB1E , 14 13 octets

Produit le nième nombre pauvre en facteurs (indexé 1)

µ3LN+Íf€gÀć›P

Essayez-le en ligne!

Explication

µ                 # loop over N (1,2,3, ...) until counter equals input
 3L               # push the range [1,2,3]
   N+             # add current N
     Í            # subtract 2
      f           # get unique prime factors of each
       €g         # get length of each factor list
         À        # rotate left
          ć       # extract the head
           ›      # check if the remaining elements are strictly greater
            P     # product
                  # if 1, increment counter
                  # implicitly output final N

Pyth, 30 25 octets

#=hTI&>l{PhTKl{PT>l{PtTKT

Ceci est mon premier vrai golf Pyth, donc tous les commentaires sont très appréciés.

Un grand merci à Xcoder!

Explication

#                         | Loop until error
 =hT                      | Add one to T (initially 10)
    I&                    | If both...
      >l{PhTKl{PT         | The number of unique prime factors of T+1 is greater than that of T (store in K) 
                 >l{PtTK  | And the number of unique prime factors of T-1 is greater than K (from before)
                        T | Then implicitly print T

TIO .

JavaScript (ES6), 94 octets

Renvoie le Nième nombre pauvre en facteurs, indexé sur 0.

f=(i,n=9)=>(P=(n,i=k=1)=>++k>n?0:n%k?P(n,1):i+P(n/k--,0))(n)>P(++n)&P(n)<P(n+1)&&!i--?n:f(i,n)

Essayez-le en ligne!

Comment?

Nous définissons d'abord la fonction P () qui renvoie le nombre de facteurs premiers uniques d'un entier donné.

P = (                   // P = recursive function taking:
  n,                    //   n = input number to test
  i =                   //   i = flag to increment the number of prime factors
  k = 1                 //   k = current divisor
) =>                    //
  ++k > n ?             // increment k; if k is greater than n:
    0                   //   stop recursion
  :                     // else:
    n % k ?             //   if k is not a divisor of n:
      P(n, 1)           //     do a recursive call with n unchanged and i = 1
    :                   //   else:
      i +               //     add i and
      P(n / k--, 0)     //     do a recursive call with n / k and i = 0; decrement k

Le code d'habillage se lit désormais comme suit:

f = (                   // given:
  i,                    //   i = input index
  n = 9                 //   n = counter
) =>                    //
  P(n) > P(++n) &       // increment n; if P(n - 1) is greater than P(n)
  P(n) < P(n + 1) &&    // and P(n) is less than P(n + 1)
  !i-- ?                // and we have reached the correct index:
    n                   //   return n
  :                     // else:
    f(i, n)             //   go on with the next value

Japt , 29 27 26 octets

Pas entièrement satisfait de cela mais au moins c'est mieux que ma première tentative qui faisait plus de 40 octets!

Sort le Nnuméro e de la séquence, indexé sur 1.

È=Jõ_+X k â ÊÃé)e>Xo)«´U}a

Essayez-le

Explication

Saisie implicite d'entier U.

È                       }a

Renvoie le premier entier Xqui retourne vrai lorsqu'il est passé par la fonction suivante.

=Jõ             )

Attribuez le tableau [-1,0,1]à X.

 _+X      Ã

Passez chaque élément de ce tableau à travers une fonction qui ajoute d'abord la valeur actuelle de X.

k â Ê

Obtenez la longueur ( Ê) des âfacteurs premiers uniques ( ) ( k) du résultat.

é

Faites pivoter le tableau résultant vers la droite.

e>Xo)

Pop ( o) le dernier élément de Xet vérifiez si tous les éléments restants sont supérieurs à lui.

«´U

Si c'est le cas, décrémentez Uet vérifiez s'il est égal à 0.

Python 3 , 97 octets

n,g=9,lambda m,k=2,p=1:m//k and(m%k<p%k)+g(m,k+1,p*k*k)
while 1:n+=1;g(n-1)>g(n)<g(n+1)!=print(n)

En théorie, cela imprime la séquence indéfiniment. En pratique, gdépasse éventuellement la limite de récursivité.

Essayez-le en ligne!

C (gcc) , 126 octets

j,t;o(n){for(j=t=0;j++<n;)if(n%j<1)for(t--;j>1>n%j;)n/=j;t=~t;}
m(J){for(J=3;;J++)if(o(J-1)>o(J)&o(J)<o(J+1))printf("%d,",J);}

Essayez-le en ligne!

Propre , 130 123 117 octets

import StdEnv
?n=[1\\q<-[p\\p<-[2..n]|and[gcd p i<2\\i<-[2..p-1]]]|n rem q<1]
f=[n\\n<-[3..]| ?n<min(?(n-1))(?(n+1))]

Correspond à un nombre infini de termes de la séquence. Puisqu'il s'agit de compréhensions imbriquées, il ne peut pas très bien profiter de la réduction de graphique et est donc assez lent, même pour un algorithme aussi mauvais.

Essayez-le en ligne!

APL NARS, 124 octets, 62 caractères

{(⍵>1E4)∨⍵≤0:¯1⋄x←9+⍳10×⍵⋄⍵↑(∊{v←⍴∘∪∘π¨⍵+2-⍳3⋄2=+/v>2⌷v}¨x)/x}

Il doit renvoyer la réponse jusqu'à 1E4, puis retourner l'erreur -1; il suppose que 9..10xargument a suffi aux bons nombres; tester:

  z←{(⍵>1E4)∨⍵≤0:¯1⋄x←9+⍳10×⍵⋄⍵↑(∊{v←⍴∘∪∘π¨⍵+2-⍳3⋄2=+/v>2⌷v}¨x)/x}  
  z 0
¯1
  z 1
11 
  z 20
11 13 19 23 25 27 29 37 41 43 47 49 53 59 61 64 67 71 73 79