Nếu một số nguyên dương có (ít) các yếu tố nguyên tố (không tính bội số) so với người kế thừa và tiền thân của nó, chúng ta sẽ gọi nó là một số yếu tố nghèo .$N > 2$

Nói cách khác, và , nơi là số thừa số nguyên tố độc đáo của N .$\omega(N) < \omega(N - 1)$$\omega(N) < \omega(N + 1)$$\omega(N)$$N$

Bài tập

Bạn có thể chọn trong số các định dạng I / O sau:

• Lấy một số nguyên $N$ và xuất ra số yếu tố nghèo $N^{\text{th}}$ . Trong trường hợp bạn chọn cái này, $N$ có thể là 0 hoặc 1 được lập chỉ mục.
• Lấy một số nguyên dương $N$ và xuất ra các số yếu tố N đầu tiên $N$.
• In trình tự vô thời hạn.

Bạn có thể nhận đầu vào và cung cấp đầu ra thông qua bất kỳ phương thức tiêu chuẩn nào , trong bất kỳ ngôn ngữ lập trình nào , trong khi lưu ý rằng các lỗ hổng này bị cấm theo mặc định. Đây là mã golf, vì vậy bài nộp ngắn nhất tuân thủ các quy tắc sẽ thắng.

Tôi sẽ không bao gồm các trường hợp thử nghiệm riêng biệt, bởi vì các phương thức cạnh tranh là khác nhau, nhưng bạn có thể tham khảo 100 điều khoản đầu tiên của chuỗi này, đó là 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

Ví dụ: $25$ xảy ra trong chuỗi này vì $\omega(25) = 1$ (5), $\omega(26) = 2$ (2 và 13) và $\omega(24) = 2$ (2 và 3), vì vậy $\omega(25) < \omega(24)$ và $\omega(25) < \omega(26)$ .

Brachylog , 21 byte

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

Hãy thử trực tuyến!

In vô hạn.

Giải trình

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

Thạch , 13 12 byte

Cr~ÆvÐṂN⁼Wø#

In số n yếu tố đầu tiên .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Hãy thử trực tuyến!

MATL , 26 24 22 byte

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

In trình tự vô thời hạn.

Hãy thử trực tuyến!

Giải trình

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

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

In trình tự vô thời hạn, thử trực tuyến hoặc xem N đầu tiên !

Hoặc §oΛ>←t có thể được sử dụng thay vì ΠtSM<←.

Giải trình

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…

Bình thường , 14 byte

.f!-.ml{Pb}tZh

Hãy thử nó ở đây!

Ban đầu nó là một gợi ý về câu trả lời của Dopapp , nhưng họ nói với tôi nên đăng nó một cách riêng biệt.

Làm thế nào nó hoạt động?

.f! -. ml {Pb} tZh | Chương trình đầy đủ. Lấy đầu vào từ STDIN, xuất N đầu tiên thành STDOUT.

.f | (var: Z) Xuất ra các giá trị N đầu tiên thỏa mãn vị ngữ.
          } tZh | Tạo danh sách [Z - 1, Z, Z + 1].
    .m | (var: b) Lấy các phần tử có giá trị hàm tối thiểu.
        Pb | Các yếu tố chính của b.
      l {| Khử trùng, lấy chiều dài.
               | Đối với một số yếu tố nghèo, điều này mang lại chính nó được bọc trong một đơn.
   - | Loại bỏ Z từ đó.
  ! | Phủ định logic.

Haskell, 105 86 byte

Cảm ơn @Wheat Wizard, @Bruce Forte và @Laikoni vì đã lưu 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]]

Octave ,  87   83  79 byte

Cảm ơn quẻ @Cows đã lưu một byte và cảm ơn @Luis Mendo vì đã lưu ba sáu byte!

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

In trình tự vô thời hạn.

Hãy thử trực tuyến!

73 byte dẫn đầu n =trước mỗi giá trị:

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

Hãy thử trực tuyến!

05AB1E , 14 13 byte

Xuất ra số yếu tố thứ n (chỉ số 1)

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

Hãy thử trực tuyến!

Giải trình

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

Bình thường, 30 25 byte

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

Đây là golf Pyth thực sự đầu tiên của tôi , vì vậy bất kỳ ý kiến ​​đều rất đánh giá cao.

Cảm ơn rất nhiều đến Xcoder!

Giải trình

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

Trả về số yếu tố thứ N, chỉ số 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)

Hãy thử trực tuyến!

Làm sao?

Trước tiên, chúng ta xác định hàm P () trả về số lượng các thừa số nguyên tố duy nhất của một số nguyên đã cho.

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

Mã gói bây giờ đọc là:

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

Không hoàn toàn hài lòng với điều này nhưng ít nhất nó tốt hơn lần thử đầu tiên của tôi trên 40 byte!

Xuất ra Nsố thứ trong chuỗi, được lập chỉ mục 1.

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

Thử nó

Giải trình

Đầu vào ngầm định của số nguyên U.

È                       }a

Trả về số nguyên đầu tiên Xtrả về true khi chuyển qua hàm sau.

=Jõ             )

Gán mảng [-1,0,1]cho X.

 _+X      Ã

Truyền từng phần tử của mảng đó thông qua một hàm trước tiên thêm giá trị hiện tại của X.

k â Ê

Lấy độ dài ( Ê) của các thừa âsố nguyên tố ( k) duy nhất ( ) của kết quả.

é

Xoay mảng kết quả một bên phải.

e>Xo)

Pop ( o) phần tử cuối cùng từ Xvà kiểm tra xem tất cả các phần tử còn lại có lớn hơn nó không.

«´U

Nếu vậy, giảm dần Uvà kiểm tra nếu nó bằng 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)

Về lý thuyết, điều này in ra trình tự vô thời hạn. Trong thực tế, gcuối cùng vượt quá giới hạn đệ quy.

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Sạch , 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))]

Tương đương với một số lượng vô hạn các điều khoản của chuỗi. Vì tất cả đều hiểu được lồng nhau, nên nó không thể tận dụng việc giảm đồ thị rất tốt và do đó khá chậm, ngay cả đối với một thuật toán tồi như vậy.

Hãy thử trực tuyến!

APL NARS, 124 byte, 62 ký tự

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

Nó sẽ trả về câu trả lời cho đến 1E4, sau đó trả về lỗi -1; nó giả sử 9..10xargument có đủ số đúng; kiểm tra:

  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