Si un entero positivo tiene (estrictamente) menos factores primos (sin contar las multiplicidades) que su sucesor y su predecesor, lo llamaremos un número de factor pobre .$N > 2$

En otras palabras, y ω ( N ) < ω ( N + 1 ) , donde ω ( N ) es el número de factores primos únicas de N .$\omega(N) < \omega(N - 1)$$\omega(N) < \omega(N + 1)$$\omega(N)$$N$

Tarea

Puede elegir entre los siguientes formatos de E / S:

• Tome un número entero y genere el número N de factor pobre. En caso de que elija este, N puede ser 0 o 1 indexado.$N$$N^{\text{th}}$$N$
• Tome un número entero positivo y genere los primeros N números pobres en factores.$N$$N$
• Imprime la secuencia indefinidamente.

Puede tomar entradas y proporcionar salidas a través de cualquier método estándar , en cualquier lenguaje de programación , mientras toma nota de que estas lagunas están prohibidas de forma predeterminada. Este es el código de golf, por lo que gana la presentación más corta que cumpla con las reglas.

No incluiré casos de prueba separados, porque los métodos de competencia son diferentes, pero puede referirse a los primeros 100 términos de esta secuencia, que es 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

Como ejemplo, ocurre en esta secuencia porque ω ( 25 ) = 1 (5), ω ( 26 ) = 2 (2 y 13) y ω ( 24 ) = 2 (2 y 3), entonces ω ( 25 ) < ω ( 24 ) y ω ( 25 ) < ω ( 26 ) .$25$$\omega(25) = 1$$\omega(26) = 2$$\omega(24) = 2$$\omega(25) < \omega(24)$$\omega(25) < \omega(26)$

Brachylog , 21 bytes

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

Pruébalo en línea!

Imprime infinitamente.

Explicación

⟨+₁≡-₁⟩                  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

Jalea , 13 12 bytes

Cr~ÆvÐṂN⁼Wø#

Imprime los primeros números de n factores pobres.

Pruébalo en línea!

Cómo funciona

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 bytes

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

Pruébalo en línea!

MATL , 26 24 22 bytes

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

Imprime la secuencia indefinidamente.

Pruébalo en línea!

Explicación

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

Casco , 22 bytes

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

Imprime la secuencia indefinidamente, pruébela en línea o vea la primera N !

Alternativamente, §oΛ>←t podría usarse en lugar deΠtSM<← .

Explicación

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 bytes

.f!-.ml{Pb}tZh

Pruébalo aquí!

Inicialmente fue una sugerencia sobre la respuesta de Dopapp , pero me dijeron que lo publicara por separado.

¿Cómo funciona?

.f! -. ml {Pb} tZh | Programa completo Toma la entrada de STDIN, emite la primera N a STDOUT.

.f | (var: Z) Muestra los primeros N valores que satisfacen el predicado.
          } tZh | Crea la lista [Z - 1, Z, Z + 1].
    .m | (var: b) Tome los elementos con un valor de función mínimo.
        Pb | Factores primos de b.
      l {| Deduplicar, obtener longitud.
               El | Para un número de factor pobre, esto se produce envuelto en un singleton.
   - | Eliminar Z de eso.
  ! El | Negación lógica

Haskell, 105 86 bytes

Gracias a @Wheat Wizard, @Bruce Forte y @Laikoni por guardar 19 bytes.

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

Octava ,  87   83  79 bytes

¡Gracias a @Cows quack por guardar un byte y gracias a @Luis Mendo por guardar tres seis bytes!

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 secuencia indefinidamente.

Pruébalo en línea!

73 bytes con un encabezado n =antes de cada valor:

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

Pruébalo en línea!

05AB1E , 14 13 bytes

Produce el enésimo número de factor pobre (1 indexado)

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

Pruébalo en línea!

Explicación

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

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

Este es mi primer Pyth golf real , por lo que cualquier comentario es muy apreciado.

¡Muchas gracias a Xcoder!

Explicación

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

Devuelve el enésimo número de factor pobre, 0 indexado.

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)

Pruébalo en línea!

¿Cómo?

Primero definimos la función P () que devuelve el número de factores primos únicos de un entero dado.

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

El código de ajuste ahora se lee como:

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 bytes

No estoy del todo contento con esto, ¡pero al menos es mejor que mi primer intento que fue de más de 40 bytes!

Emite el Nnúmero th en la secuencia, 1 indexado.

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

Intentalo

Explicación

Entrada implícita de entero U.

È                       }a

Devuelve el primer entero Xque devuelve verdadero cuando se pasa por la siguiente función.

=Jõ             )

Asigne la matriz [-1,0,1]a X.

 _+X      Ã

Pase cada elemento de esa matriz a través de una función que primero agrega el valor actual de X.

k â Ê

Obtenga la longitud ( Ê) de los âfactores primos únicos ( ) kdel resultado.

é

Gire el conjunto resultante uno a la derecha.

e>Xo)

Pop ( o) el último elemento de Xy compruebe si todos los elementos restantes son mayores que él.

«´U

Si es así, disminuya Uy verifique si es igual a 0.

Python 3 , 97 bytes

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 teoría, esto imprime la secuencia indefinidamente. En la práctica, geventualmente excede el límite de recursión.

Pruébalo en línea!

C (gcc) , 126 bytes

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

Pruébalo en línea!

Limpio , 130 123 117 bytes

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

Equivale a un número infinito de términos de la secuencia. Como se trata de comprensiones anidadas, no puede aprovechar muy bien la reducción de gráficos y, por lo tanto, es bastante lento, incluso para un algoritmo tan malo.

Pruébalo en línea!

NARS APL, 124 bytes, 62 caracteres

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

Debería devolver la respuesta hasta 1E4, luego devolver -1 error; supone que 9..10xargumento tiene suficientes números correctos; prueba:

  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