正の整数の場合 $N > 2$

言い換えると、 $\omega(N) < \omega(N - 1)$ そして $\omega(N) < \omega(N + 1)$、ここで $\omega(N)$ の一意の素因数の数です $N$.

仕事

次のI / O形式から選択できます。

• 整数を取る $N$ そして出力 $N^{\text{th}}$因子が少ない数。これを選択した場合、$N$ 0または1のインデックスを付けることができます。
• 正の整数を取る $N$ そして最初の出力 $N$ 要因の少ない数。
• シーケンスを無期限に印刷します。

これらの抜け穴はデフォルトでは禁止されていることに注意しながら、任意のプログラミング言語で、任意の標準メソッドを介して入力を取得し、出力を提供できます。これはコードゴルフであるため、ルールに従った最短の提出が勝ちです。

競合する方法が異なるため、個別のテストケースは含めませんが、このシーケンスの最初の100の用語である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

例として、 $25$ このシーケンスで発生するのは $\omega(25) = 1$ （5）、 $\omega(26) = 2$ （2および13）および $\omega(24) = 2$ （2および3）ので、 $\omega(25) < \omega(24)$ そして $\omega(25) < \omega(26)$。

Brachylog、21バイト

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

オンラインでお試しください！

無限に印刷します。

説明

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

ゼリー、13 12バイト

Cr~ÆvÐṂN⁼Wø#

最初のn個の因子の少ない数を出力します。

オンラインでお試しください！

使い方

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.

パイソン2、123の 119バイト

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

オンラインでお試しください！

MATL、26 24 22バイト

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

シーケンスを無期限に印刷します。

オンラインでお試しください！

説明

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

殻、22バイト

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

シーケンスを無期限に印刷するか、オンラインで試すか、最初のNを表示します！

または、の代わりに§oΛ>←t 使用できますΠtSM<←。

説明

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バイト

.f!-.ml{Pb}tZh

ここで試してみてください！

最初はDopappの回答に関する提案でしたが、彼らは個別に投稿するように言っていました。

使い方？

.f！-。ml {Pb} tZh | 完全なプログラム。STDINから入力を受け取り、最初のNをSTDOUTに出力します。

.f | （var：Z）述語を満たす最初のN値を出力します。
          } tZh | リスト[Z-1、Z、Z + 1]を作成します。
    .m | （var：b）関数値が最小の要素を取ります。
        鉛| bの素因数
      l {| 重複排除、長さを取得します。
               | 因子が少ない数の場合、これはシングルトンにラップされて生成されます。
   -| Zを削除します。
  ！| 論理否定。

Haskell、105 86バイト

19バイトを節約してくれた@Wheat Wizard、@ Bruce Forte、および@Laikoniに感謝します。

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

オクターブ、 87   83  79バイト

節約のために@Luis Mendoにバイトと感謝を保存するための@Cowsいんちきのおかげで3つの 6バイトを！

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

シーケンスを無期限に印刷します。

オンラインでお試しください！

n =各値の前に先行する73バイト：

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

オンラインでお試しください！

05AB1E、14 13バイト

n番目の因子の少ない数を出力します（1-indexed）

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

オンラインでお試しください！

説明

µ                 # 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バイト

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

これは私の最初の本物の Pythゴルフですので、コメントは大歓迎です。

Xcoderに大いに感謝します！

説明

#                         | 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バイト

インデックスが0のN番目の因子の少ない数を返します。

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)

オンラインでお試しください！

どうやって？

最初に、指定された整数の一意の素因数の数を返すP（）関数を定義します。

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

ラッピングコードは次のようになります。

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バイト

これに完全に満足しているわけではありませんが、少なくとも40バイトを超える最初の試みよりはましです。

Nシーケンスの1番目のインデックスを1番目に出力します。

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

それを試してみてください

説明

integerの暗黙的な入力U。

È                       }a

X次の関数に渡されたときにtrueを返す最初の整数を返します。

=Jõ             )

に配列[-1,0,1]を割り当てXます。

 _+X      Ã

その配列の各要素を、最初に現在の値を追加する関数に渡しますX。

k â Ê

結果Êの一意の（â）素因数（）の長さ（）を取得しkます。

é

結果の配列を1つ右に回転します。

e>Xo)

oから最後の要素をポップ（）し、X残りのすべての要素がそれより大きいかどうかを確認します。

«´U

その場合は、デクリメントしてU、0に等しいかどうかを確認します。

Python 3、97バイト

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)

理論的には、これはシーケンスを無期限に出力します。実際には、g最終的に再帰制限を超えます。

オンラインでお試しください！

C（gcc）、126バイト

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

オンラインでお試しください！

クリーン、130の 123 117バイト

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

シーケンスの無限の数の項に相当します。ネストされた内包表記であるため、グラフの縮小をうまく利用できないため、このような悪いアルゴリズムであっても非常に遅くなります。

オンラインでお試しください！

APL NARS、124バイト、62文字

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

1E4まで回答を返し、-1エラーを返します。9..10xargumentに十分な数があると仮定します。テスト：

  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