Se um número inteiro positivo $N > 2$ tiver (estritamente) menos fatores primos (sem contar as multiplicidades) que seu sucessor e seu antecessor, o chamaremos de número pobre em fatores .

Em outras palavras, $\omega(N) < \omega(N - 1)$ e $\omega(N) < \omega(N + 1)$ , onde é o número de factores primos únicas de .$\omega(N)$$N$

Tarefa

Você pode escolher entre os seguintes formatos de E / S:

• Pegue um número inteiro e produza o número pobre de fatores . Caso você escolha este, pode ser 0 ou 1 indexado.N th$N$$N^{\text{th}}$$N$
• Pegue um número inteiro positivo e produza os primeiros N números pobres em fatores.$N$$N$
• Imprima a sequência indefinidamente.

Você pode obter entrada e fornecer saída através de qualquer método padrão , em qualquer linguagem de programação , observando que essas brechas são proibidas por padrão. Esse é o código de golfe, então a submissão mais curta que obedece às regras vence.

Não incluirei casos de teste separados, porque os métodos de competição são diferentes, mas você pode consultar os 100 primeiros termos desta sequência, que é 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 exemplo, ocorre nesta sequência porque ω ( 25 ) = 1 (5), ω ( 26 ) = 2 (2 e 13) e ω ( 24 ) = 2 (2 e 3), então ω ( 25 ) < ω ( 24 ) e ω ( 25 ) < ω ( 26 ) .$25$$\omega(25) = 1$$\omega(26) = 2$$\omega(24) = 2$$\omega(25) < \omega(24)$$\omega(25) < \omega(26)$

Braquilog , 21 bytes

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

Experimente online!

Imprime infinitamente.

Explicação

⟨+₁≡-₁⟩                  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éia , 13 12 bytes

Cr~ÆvÐṂN⁼Wø#

Imprime os primeiros n números com fator ruim.

Experimente online!

Como 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

Experimente online!

MATL , 26 24 22 bytes

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

Imprime a sequência indefinidamente.

Experimente online!

Explicação

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

Casca , 22 bytes

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

Imprime a sequência indefinidamente, tente online ou visualize o primeiro N !

Alternativamente, §oΛ>←t pode ser usado em vez de ΠtSM<←.

Explicação

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…

Pitão , 14 bytes

.f!-.ml{Pb}tZh

Experimente aqui!

Inicialmente, foi uma sugestão sobre a resposta da Dopapp , mas eles me disseram para publicá-la separadamente.

Como funciona?

.f! -. ml {Pb} tZh | Programa completo. Pega a entrada de STDIN, gera o primeiro N para STDOUT.

.f (var: Z) Gera os primeiros N valores que satisfazem o predicado.
          } tZh | Cria a lista [Z - 1, Z, Z + 1].
    .m (var: b) Pegue os elementos com valor mínimo de função.
        Pb Fatores primos de b.
      eu {| Desduplicar, obter comprimento.
               | Para um número pobre de fatores, isso se produz envolto em um singleton.
   - | Remova Z disso.
  ! | Negação lógica.

Haskell, 105 86 bytes

Agradecemos ao @Wheat Wizard, @Bruce Forte e @Laikoni por salvar 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]]

Oitava ,  87   83  79 bytes

Agradecemos ao @Cows quack por salvar um byte e ao @Luis Mendo por salvar três 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 a sequência indefinidamente.

Experimente online!

73 bytes com avanço 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

Experimente online!

05AB1E , 14 13 bytes

Emite o enésimo número de fator ruim (indexado 1)

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

Experimente online!

Explicação

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

Pitão, 30 25 bytes

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

Este é o meu primeiro golfe real em Pyth, então qualquer comentário é muito apreciado.

Um grande obrigado ao Xcoder!

Explicação

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

Retorna o número enésimo fator pobre, indexado 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)

Experimente online!

Quão?

Primeiro, definimos a função P () que retorna o número de fatores primos exclusivos de um dado inteiro.

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

O código de empacotamento agora é lido 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

Não totalmente feliz com isso, mas pelo menos é melhor do que minha primeira tentativa, que tinha mais de 40 bytes!

Emite o Nnúmero th na sequência, indexada em 1.

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

Tente

Explicação

Entrada implícita de número inteiro U.

È                       }a

Retorne o primeiro número inteiro Xque retorna true quando passado pela função a seguir.

=Jõ             )

Atribua a matriz [-1,0,1]a X.

 _+X      Ã

Passe cada elemento desse array por uma função que primeiro adicione o valor atual de X.

k â Ê

Obtenha o comprimento ( Ê) dos âfatores únicos ( ) primos ( k) do resultado.

é

Gire a matriz resultante uma para a direita.

e>Xo)

Retire ( o) o último elemento de Xe verifique se todos os elementos restantes são maiores que ele.

«´U

Nesse caso, diminua Ue verifique se é 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)

Em teoria, isso imprime a sequência indefinidamente. Na prática, geventualmente excede o limite de recursão.

Experimente online!

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

Experimente online!

Limpo , 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 um número infinito de termos da sequência. Como são todas as compreensões aninhadas, não é possível aproveitar muito bem a redução de gráficos e, portanto, é bastante lento, mesmo para um algoritmo tão ruim.

Experimente online!

NARS APL, 124 bytes, 62 caracteres

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

Ele deve retornar a resposta até 1E4, depois retornar -1 erro; supõe que 9..10xargumento tenha números suficientes; teste:

  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