Jika bilangan bulat positif memiliki (secara ketat) lebih sedikit faktor prima (tanpa menghitung multiplisitas) daripada penggantinya dan pendahulunya, kami akan menyebutnya bilangan faktor-miskin .$N > 2$

Dengan kata lain, dan ω ( N ) < ω ( N + 1 ) , di mana ω ( N ) adalah sejumlah faktor prima yang unik dari N .$\omega(N) < \omega(N - 1)$$\omega(N) < \omega(N + 1)$$\omega(N)$$N$

Tugas

Anda dapat memilih di antara format I / O berikut:

• Ambil bilangan bulat dan hasilkan angka miskin faktor ke - N . Jika Anda memilih yang ini, N bisa 0 atau 1 diindeks.$N$$N^{\text{th}}$$N$
• Ambil bilangan bulat positif dan hasilkan angka pertama faktor-miskin $N$$N$
• Cetak urutan tanpa batas.

Anda dapat mengambil input dan memberikan output melalui metode standar apa pun , dalam bahasa pemrograman apa pun , sambil memperhatikan bahwa celah ini dilarang secara default. Ini golf kode, jadi pengiriman terpendek yang mematuhi aturan menang.

Saya tidak akan menyertakan kotak uji terpisah, karena metode bersaingnya berbeda, tetapi Anda dapat merujuk ke 100 syarat pertama dari urutan ini, yaitu 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

Sebagai contoh, terjadi dalam urutan ini karena ω ( 25 ) = 1 (5), ω ( 26 ) = 2 (2 dan 13) dan ω ( 24 ) = 2 (2 dan 3), jadi ω ( 25 ) < ω ( 24 ) dan ω ( 25 ) < ω ( 26 ) .$25$$\omega(25) = 1$$\omega(26) = 2$$\omega(24) = 2$$\omega(25) < \omega(24)$$\omega(25) < \omega(26)$

Brachylog , 21 byte

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

Cobalah online!

Mencetak tanpa batas.

Penjelasan

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

Jelly , 13 12 byte

Cr~ÆvÐṂN⁼Wø#

Mencetak angka pertama n faktor-buruk.

Cobalah online!

Bagaimana itu bekerja

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 byte

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

Cobalah online!

MATL , 26 24 22 byte

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

Mencetak urutan tanpa batas.

Cobalah online!

Penjelasan

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

Sekam , 22 byte

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

Mencetak urutan tanpa batas, coba online atau lihat N pertama !

Atau §oΛ>←t bisa digunakan sebagai pengganti ΠtSM<←.

Penjelasan

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 byte

.f!-.ml{Pb}tZh

Coba di sini!

Awalnya itu adalah saran tentang jawaban Dopapp , tetapi mereka mengatakan kepada saya untuk mempostingnya secara terpisah.

Bagaimana itu bekerja?

.f! -. ml {Pb} tZh | Program lengkap. Mengambil input dari STDIN, mengeluarkan N pertama hingga STDOUT.

.f | (var: Z) Keluarkan nilai N pertama yang memenuhi predikat.
          } tZh | Membuat daftar [Z - 1, Z, Z + 1].
    .m | (var: b) Ambil elemen dengan nilai fungsi minimal.
        Pb | Faktor utama b.
      l {| Deduplicate, dapatkan panjangnya.
               | Untuk sejumlah faktor-miskin, hasil ini sendiri terbungkus dalam singleton.
   - | Hapus Z dari itu.
  ! | Negasi logis.

Haskell, 105 86 byte

Terima kasih kepada @Wheat Wizard, @Bruce Forte, dan @Laikoni karena telah menghemat 19 byte.

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

Oktaf ,  87  ,  83  79 byte

Terima kasih kepada @Cows dukun untuk menyimpan satu byte dan terima kasih kepada @Luis Mendo karena telah menyimpan tiga enam byte!

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

Mencetak urutan tanpa batas.

Cobalah online!

73 byte dengan memimpin n =sebelum setiap nilai:

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

Cobalah online!

05AB1E , 14 13 byte

Menghasilkan angka ke-miskin-faktor (1-diindeks)

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

Cobalah online!

Penjelasan

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

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

Ini adalah pertama saya nyata Pyth golf, jadi komentar sangat dihargai.

Terima kasih banyak kepada Xcoder!

Penjelasan

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

Mengembalikan angka N-faktor-buruk, 0-diindeks.

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)

Cobalah online!

Bagaimana?

Kami pertama-tama mendefinisikan fungsi P () yang mengembalikan jumlah faktor prima unik bilangan bulat yang diberikan.

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

Kode pembungkus sekarang terbaca sebagai:

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 byte

Tidak sepenuhnya senang dengan ini, tetapi setidaknya lebih baik daripada upaya pertama saya yang lebih dari 40 byte!

Menghasilkan angka Nke-1 dalam urutan, 1-diindeks.

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

Cobalah

Penjelasan

Input bilangan bulat implisit U.

È                       }a

Kembalikan integer pertama Xyang mengembalikan true ketika melewati fungsi berikut.

=Jõ             )

Tetapkan array [-1,0,1]ke X.

 _+X      Ã

Lewati setiap elemen array itu melalui fungsi yang pertama menambahkan nilai saat ini dari X.

k â Ê

Dapatkan panjang ( Ê) faktor unik ( â) prima ( k) dari hasilnya.

é

Putar array yang dihasilkan ke kanan.

e>Xo)

Pop ( o) elemen terakhir dari Xdan periksa apakah semua elemen yang tersisa lebih besar dari itu.

«´U

Jika demikian, kurangi Udan periksa apakah sama dengan 0.

Python 3 , 97 byte

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)

Secara teori, ini mencetak urutan tanpa batas. Dalam praktiknya, gakhirnya melebihi batas rekursi.

Cobalah online!

C (gcc) , 126 byte

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

Cobalah online!

Bersih , 130 123 117 byte

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

Setara dengan jumlah syarat urutan yang tak terbatas. Karena semuanya bersarang, ia tidak dapat memanfaatkan pengurangan grafik dengan sangat baik sehingga sangat lambat, bahkan untuk algoritma yang buruk.

Cobalah online!

APL NARS, 124 byte, 62 karakter

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

Seharusnya mengembalikan jawaban hingga 1E4, lalu mengembalikan -1 kesalahan; anggaplah 9..10 dokumen memiliki angka yang tepat; uji:

  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