定義

平方のないセミプライムは、2つの異なる素数の積である自然数です。

タスク

自然数が与えられたn場合、に等しいかそれ以下のすべての正方形のないセミプライムを数えますn。

細部

単一の整数パラメーターを受け入れ、そのパラメーター以下の正方形のないセミプライムをすべてカウントする関数またはプロシージャーを記述してください。カウントは、関数呼び出しの戻り値であるか、STDOUTに出力される必要があります。

得点

最も少ない文字数の答えが勝ちます。

同点の場合、次の基準が順番に使用されます。

1. 一番高い人

2. 最高の時間の複雑さ

3. 最悪のスペースの複雑さ

例

f(1)     = 0
f(62)    = 18
f(420)   = 124
f(10000) = 2600

J、50 40 38 37文字

f=:3 :'+/y<:}.~.,(~:/**/)~p:i._1&p:y'

使用法：

   f 1
0
   f 62
18
   f 420
124
   f 10000
2600

FUZxxlに感謝します。

性能試験

   showtotal_jpm_ ''[f 1[start_jpm_ ''
 Time (seconds)
┌───────┬──────┬────────┬────────┬─────┬────┬───┐
│name   │locale│all     │here    │here%│cum%│rep│
├───────┼──────┼────────┼────────┼─────┼────┼───┤
│f      │base  │0.000046│0.000046│100.0│100 │1  │
│[total]│      │        │0.000046│100.0│100 │   │
└───────┴──────┴────────┴────────┴─────┴────┴───┘
   showtotal_jpm_ ''[f 1[f 62[start_jpm_ ''
 Time (seconds)
┌───────┬──────┬────────┬────────┬─────┬────┬───┐
│name   │locale│all     │here    │here%│cum%│rep│
├───────┼──────┼────────┼────────┼─────┼────┼───┤
│f      │base  │0.000095│0.000095│100.0│100 │2  │
│[total]│      │        │0.000095│100.0│100 │   │
└───────┴──────┴────────┴────────┴─────┴────┴───┘
   showtotal_jpm_ ''[f 1[f 62[f 420[start_jpm_ ''
 Time (seconds)
┌───────┬──────┬────────┬────────┬─────┬────┬───┐
│name   │locale│all     │here    │here%│cum%│rep│
├───────┼──────┼────────┼────────┼─────┼────┼───┤
│f      │base  │0.000383│0.000383│100.0│100 │3  │
│[total]│      │        │0.000383│100.0│100 │   │
└───────┴──────┴────────┴────────┴─────┴────┴───┘
   showtotal_jpm_ ''[f 1[f 62[f 420[f 10000[start_jpm_ ''
 Time (seconds)
┌───────┬──────┬────────┬────────┬─────┬────┬───┐
│name   │locale│all     │here    │here%│cum%│rep│
├───────┼──────┼────────┼────────┼─────┼────┼───┤
│f      │base  │0.084847│0.084847│100.0│100 │4  │
│[total]│      │        │0.084847│100.0│100 │   │
└───────┴──────┴────────┴────────┴─────┴────┴───┘
   showtotal_jpm_ ''[f 1[f 62[f 420[f 10000[f 50000[start_jpm_ ''
 Time (seconds)
┌───────┬──────┬────────┬────────┬─────┬────┬───┐
│name   │locale│all     │here    │here%│cum%│rep│
├───────┼──────┼────────┼────────┼─────┼────┼───┤
│f      │base  │5.014691│5.014691│100.0│100 │5  │
│[total]│      │        │5.014691│100.0│100 │   │
└───────┴──────┴────────┴────────┴─────┴────┴───┘

私は過去にここで見たような理論家ではありませんが、時間の複雑さはO（n _p ²）のようなものだと思います。ここで、n _pは入力数nまでの素数で、入力数nを含みます。これは、（非常に大きな乗算テーブルを生成する）私の方法の複雑さが、Jに組み込まれた素数生成関数の複雑さをはるかに上回るという仮定に基づいています。

説明

f=:3 :'...'（モナド）動詞（関数）を宣言します。動詞への入力はy、動詞定義内で表されます。

p:i._1&p:yp:動詞は動詞多目的素数であり、それはここでは2つの異なる方法で使用されています：_1&p:y未満の素数の数を返しy、その後p:i.それらの一つ一つを生成します。入力として10を使用：

   p:i._1&p:10
2 3 5 7

(~:/**/)~先ほど話したテーブルを生成します。*/乗算テーブルを~:/生成し、等しくないテーブルを生成し（二乗を排除するため）、これらの両方を一緒に乗算します。以前の出力を入力として使用：

   */~2 3 5 7
 4  6 10 14
 6  9 15 21
10 15 25 35
14 21 35 49

   ~:/~2 3 5 7
0 1 1 1
1 0 1 1
1 1 0 1
1 1 1 0

   (~:/**/)~2 3 5 7
 0  6 10 14
 6  0 15 21
10 15  0 35
14 21 35  0

}.~.,ここで、数値を1つのリスト,に変換して一意の値~.を取得し、最初の0を削除します}.

   }.~.,(~:/**/)~2 3 5 7
6 10 14 15 21 35

y<: 有効な値を確認するための元の入力との比較：

   10<:6 10 14 15 21 35
1 1 0 0 0 0

+/ そして、それを合計して答えを得ます。

   +/1 1 0 0 0 0
2

Mathematica 65 64 55 51 47 39

コード

次の例では、以下の正方形のないセミプライムの数をカウントしnます。

FactorInteger@Range@n~Count~{a={_,1},a}

正方形のないセミプライム因子を次の形式の構造に組み込みます{{p,1}{q,1}} 。たとえば、

FactorInteger@221
(* out *)
{{13, 1},{17, 1}}

ルーチンは単純に、この因子の構造を持つ望ましい範囲内の数を数えます。

使用法

n=62;
FactorInteger@Range@n~Count~{a={_,1},a}

(* out *)
18

タイミング：与えられたすべての例

FactorInteger@Range@#~Count~{a = {_, 1}, a} & /@ {1, 62, 420, 10^4} // Timing

(* out *)
{0.038278, {0, 18, 124, 2600}}

タイミング：n = 10 ^ 6

100万以下の正方形のないセミプライムの数を数えるには、4秒未満かかります。

n=10^6;
FactorInteger@Range@n~Count~{a = {_, 1}, a}//Timing
(* out *)
{3.65167, 209867}

Python、115

r=range
p=lambda x:all(x%i for i in r(2,x))
f=lambda x:sum([i*j<=x and p(j)and p(i)for i in r(2,x)for j in r(2,i)])

ゼリー、7バイト

ŒcfÆf€L

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

使い方

ŒcfÆf€L  Main link. Argument: n

Œc       Generate all 2-combinations of [1, ..., n], i.e., all pairs [a, b] such
         that 1 ≤ a < b ≤ n.
   Æf€   Compute the prime factorization of each k in [1, ..., n].
  f      Filter; keep only results that appear to the left and to the right.
      L  Take the length.

パイソン（139）

from itertools import*;s=lambda n:sum(x*y<=n and x<y for x,y in product(filter(lambda x:all(x%i for i in range(2,x)),range(2,n)),repeat=2))

競合他社がプログラムをテストできるように、いくつかのサンプル結果を提供してください。

ルビー82

z=->n{[*2..n].select{|r|(2...r).all?{|m|r%m>0}}.combination(2).count{|a,b|a*b<=n}}

デモ：http : //ideone.com/cnm1Z

Python 139

def f(n):
 p=[];c=0
 for i in range(2,n+1):
    if all(i%x for x in p):p+=[i]
    c+=any((0,j)[i/j<j]for j in p if i%j==0 and i/j in p)
 return c

Golfscript 64

~:ß,{:§,{)§\%!},,2=},0+:©{©{1$}%\;2/}%{+}*{..~=\~*ß>+\0?)+!},,2/

オンラインデモはこちら

注：上記のデモでは、420および10000テストケースを除外しました。非常に非効率的な素数性テストのため、これらの入力に対して5秒未満でプログラムを実行することはできません。

シェル、40

＃！/ bin / sh

seq $ 1 | factor | awk 'NF == 3 && $ 2！= $ 3' | wc -l

＃古い、61
#seq $ 1 | factor | awk 'BEGIN {a = 0} NF == 3 && $ 2！= $ 3 {a ++} END {print a}'

使用法：

$ ./カウント1
0
$ ./カウント420
124
$ ./カウント10000
2600
$時間./cnt.sh 1000000
209867

実数0分23.956秒
ユーザー0m23.601s
sys 0m0.404s

ゼリー、14 13バイト

RÆEḟ0⁼1,1$Ɗ€S

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

RÆEḟ0⁼1,1$Ɗ€S    main function:
RÆE             get the prime factorization Exponents on each of the Range from 1 to N,
          Ɗ€    apply the preceding 1-arg function composition (3 funcs in a row) to each of the prime factorizations:
                (the function is a monadic semiprime checker, as per DavidC's algorithm)
    ḟ0          check if the factors minus the zero exponents...
      ⁼1,1$      ...are equal to the list [1,1]
             S   take the Sum of those results, or number of successes!

建設的な批判は歓迎されました！

Pythonの2/3、95の 94バイト

lambda n:sum(map(F,range(n+1)))
F=lambda x,v=2:sum(x%i<1and(F(i,0)or 3)for i in range(2,x))==v

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

新しいPythonレコードを設定するため、6年前の課題で投稿されました。IMOはかなり興味深いアプローチです。

説明

lambda n:sum(map(F,range(n+1)))           # Main function, maps `F` ("is it a semiprime?")
                                          #  over the range [0, n]
F=lambda x,v=2:                           # Helper function; "Does `x` factor into `v`
                                          #  distinct prime numbers smaller than itself?"
  sum(                                    # Sum over all numbers `i` smaller than `x`
    x%i<1                                 # If `i` divides `x`,
    and                                   #  then
    (F(i,0)                               #  add 1 if `i` is prime (note that `F(i,0)`
                                          #  is just a primality test for `i`!)
    or 3)                                 #  or `3` if `i` is not prime (to make `F`
                                          #  return `False`)
  for i in range(2,x))
  ==v                                     # Check if there were exactly `v` distinct prime
                                          #  factors smaller than `x`, each with
                                          #  multiplicity 1

Python 2/3（PyPy）、88 82 81バイト

lambda n:sum(sum(x%i<1and(x/i%i>0or 9)for i in range(2,x))==2for x in range(n+1))

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

Value Inkによる92バイトのゴルフに基づいています。PyPyは0or、を正しく解釈するために必要です。これは、標準のPythonではこれを8進数での試行と見なしているためです。

Stax、8 バイト

ߺ@N¬Që↔

実行してデバッグする

開梱、ゴルフ、コメントをすると、次のようになります。

F       for 1..n run the rest of the program
  :F    get distinct prime factors
  2(    trim/pad factor list to length 2
  :*    compute product of list
  _/    integer divide by initial number (yielding 0 or 1)
  +     add to running total

これを実行

Perl 6の、58の 45バイト

-13バイトのJo Kingに感謝します。

{+grep {3==.grep($_%%*)&&.all³-$_}o^*,1..$_}

4つの因子を持つ整数は、平方のないセミプライムまたは完全な立方体であるという事実を利用します。

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

Brachylog、7バイト

{≥ḋĊ≠}ᶜ

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

           The output is
{    }ᶜ    the number of ways in which you could
 ≥         choose a number less than or equal to
           the input
  ḋ        such that its prime factorization
   Ċ       is length 2
    ≠      with no duplicates.

Retina、58バイト

_
¶_$`
%(`$
$"
,,`_(?=(__+)¶\1+$)
¶1$'
)C`1(?!(__+)\1+¶)
2

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

_タリーマークと一緒に入力単項として受け取ります

説明

自分自身と1を除いた最大および最小の因子が両方とも素数である場合、その数は平方のない準素数です。

_
¶_$`

入力を受け取り、それ以下の各単項をそれぞれ独自の行に生成します

%(`

その後、各番号について...

$
$"
,,`_(?=(__+)¶\1+$)
¶1$'

1を除いて、その最小および最大の因子を見つけます...

)C`1(?!(__+)\1+¶)

素数であるそれらの数を数えます。最小の因子は素数でなければならないため、これは1または2を返します

2

2の総数を数える

パイソン2、105の 104バイト

lambda m:sum(reduce(lambda(a,v),p:(v*(a+(n%p<1)),v>0<n%p**2),range(2,n),(0,1))[0]==2for n in range(m+1))

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

squidに 1バイトthx🦑

Ruby -rprime、64バイト

ここには別のRubyソリューションがあることはわかっていますが、2012年に回答されて以来、コメントでぶつけたくありませんでした。そして、結局のところ、プログラムフラグを使用すると、別の言語としてカウントされます。技術的にはとにかく「Ruby」ではありません。

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

説明

->n{(1..n).count{|i|m=i.prime_division;m.size|m.sum(&:last)==2}}
->n{                                    # Anonymous lambda
    (1..n).count{|i|                    # Count all from 1 to `n` that match
                                        # the following condition
                m=i.prime_division;     # Get the prime factors of `i` as
                                        #  base-exponent pairs (e.g. [2,3])
                m.size                  # Size of factors (# of distinct primes)
                      |                 # bit-or with...
                       m.sum(&:last)    # Sum of the last elements in the pairs
                                        #  (the sum of the exponents)
                                    ==2 # Check if that equals 2 and return.
                                        # Because 2 is 0b10, the bit-or means
                                        #  that the condition is true iff both
                                        #  are either 2 or 0, but because this
                                        #  is a prime factorization, it is
                                        #  impossible to have the number of
                                        #  distinct primes or the sum of the
                                        #  exponents to equal 0 for any number
                                        #  > 1. (And for 1, size|sum == 0.)
    }                                   # End count block
}                                       # End lambda

APL（NARS）、文字26、バイト52

{≢b/⍨{(⍵≡∪⍵)∧2=≢⍵}¨b←π¨⍳⍵}

テスト：

  f←{≢b/⍨{(⍵≡∪⍵)∧2=≢⍵}¨b←π¨⍳⍵}
  f 1
0
  f 9
1
  f 62
18
  f 420
124
  f 1000
288
  f 10000
2600
  f 100000
23313

これはより長い代替手段です（私が好む59文字）

r←h w;n;t
n←4⋄r←0
n+←1⋄→0×⍳w<n⋄→2×⍳(2≠≢t)∨2≠≢∪t←πn⋄r+←1⋄→2

テスト：

  h 1000000
209867