表示自然数的一种方法是乘以质数的指数。例如，6可以由2 ^ 1 * 3 ^ 1表示，而50可以由2 ^ 1 * 5 ^ 2表示（其中^表示指数）。与其他方法相比，此表示形式中的质数可以帮助确定使用这种表示方法是否更短。但是因为我不想手工计算这些，所以我需要一个程序为我做这些。但是，由于在回家之前我必须记住该程序，因此它必须尽可能短。

你的任务：

编写程序或函数以确定该数字表示形式中有多少个不同的质数。

输入：

通过任何常规方法获取的整数n，使得1 <n <10 ^ 12。

输出：

引言中概述了表示输入所需的不同素数的数量。

测试用例：

24      -> 2 (2^3*3^1)
126     -> 3 (2^1*3^2*7^1)
1538493 -> 4 (3^1*11^1*23^1*2027^1)
123456  -> 3 (2^6*3^1*643^1)

这是OEIS A001221。

得分：

这是代码高尔夫球，最低得分（以字节为单位）获胜！

— 狮phon
source

3

最近有很多主要问题！我喜欢它。

— 朱塞佩

2

MATL，4 3字节

-1字节感谢Luis Mendo

YFz

在线尝试！

YF         Exponents of prime factors
  z        Number of nonzeros

原始答案：

Yfun

在线尝试！

一个正确的Yfun答案。

          (Implicit input)
Yf         Prime factorization
  u        Unique
   n       Numel
           (Implicit output)

— 朱塞佩
source

1

为什么好玩？- ;-)

— 亚当

1

划掉4仍然是常规4

— Gryphon

5

05AB1E，2个字节

^{另一个很无聊的答案...}

fg

接受数字输入并打印结果的完整程序

在线尝试！

怎么样？

fg - implicitly take input
f  - get the prime factors with no duplicates
 g - get the length
   - implicit print

— 乔纳森·艾伦
source

5

Mathematica，7个字节

PrimeNu

是的，有一个内置的。

Mathematica，21个字节

Length@*FactorInteger

很长的路要走。

— 米莎·拉夫罗夫（Misha Lavrov）
source

星号的原因是什么？不Length@FactorInteger一样吗

— numbermaniac

1

Length@*FactorInteger产生一个纯函数：的组成Length和FactorInteger。我可以定义fun=Length@*FactorInteger然后致电fun[1001]。另一方面，Length@FactorInteger将表示Length[FactorInteger]并求值为0。

— Misha Lavrov

5

盖亚 2字节

^{另一个无聊的答案……-J. Allan}

ḋl

在线尝试！

ḋ- 素数分解为[素数，指数]对。
l - 长度。

— Xcoder先生
source

4

Python 2，56个字节

f=lambda n,p=2,k=1:n/p and[f(n,p+1),k+f(n/p,p,0)][n%p<1]

— 奥尔普
source

这是丹尼斯的回答的端口这里或许？

— 乔纳森·艾伦，

1

@JonathanAllan是的，已修改为计算唯一的主要因子。

— Orlp

4

视网膜，31 30字节

&`(?!(11+)\1+$)(11+)$(?<=^\2+)

输入为一元。

感谢@MartinEnder进行1字节的高尔夫！

在线尝试！（包括十进制到一进制转换器）

怎么运行的

由于该程序由单个正则表达式和 &修饰符，因此Retina只需计算重叠匹配的数量即可。假定输入由n个重复1组成，没有其他内容。

负面的前瞻

(?!(11+)\1+$)

在之间的位置匹配1的那些不遵循由两个或更多个1的（11+），随后在相同量的一个或多个重复1的（\1+），随后输入结束（$）。

任何合数AB与A，B> 1可以写为b的重复一个的重复1，所以先行仅位置，随后匹配p的重复 1，其中P = 1或p是素数。

正则表达式

(11+)$

确保P> 1通过要求至少两个1的（11+），并且存储的尾1 'S中的第二捕获组（\2）。

最后，积极的回望

(?<=^\2+)

验证整个输入是否包含kp次出现（k≥1）为1，并验证p对输入进行了除法。

因此，每个匹配项对应一个唯一的素数除数p。

— 丹尼斯
source

4

Bash + GNU实用程序，33

@Dennis节省了1个字节

factor|grep -Po ' \d+'|uniq|wc -l

在线尝试。

说明

factor|                            # Split input into prime factors
       grep -Po ' \d+'|            # group factors onto lines
                       uniq|       # remove duplicates
                            wc -l  # count the lines

— 数字创伤
source

1

grep -Po ' \d+'保存一个字节tr \ \\n|sed 1d。

— 丹尼斯，

不幸的是，grep -Po '( \d+)\1*'输入46失败。

— 丹尼斯

@Dennis谢谢-我是根据您的原始建议修正的

— Digital

3

果冻，3 个字节

^{一个很无聊的答案...}

ÆFL

单数链接，获取一个数字并返回一个数字

在线尝试！

怎么样？

ÆFL - Link: number, n
ÆF  - prime factorisation as a list of prime, exponent pairs
  L - length

— 乔纳森·艾伦
source

1

你是怎么想念的Æv？

— 我的代名词是monicareinstate '17

这很容易-我从未使用过它，也没有在Wiki上搜索列表。

— 乔纳森·艾伦

您如何键入没有原子列表和快速列表的果冻字符？

— 我的代词是monicareinstate '17

1. Æ是替代代码0198。2.您可以设置键盘（我没有）。3.代码页。

— 乔纳森·艾伦

3

欧姆v2，2个字节

ml

在线尝试！

在文档中，两个内置插件彼此相邻。

— 全人类
source

3

果冻，2个字节

^{另一个无聊的答案……-J. Allan}

Æv

在线尝试！

内置的。

— Xcoder先生
source

3

爱丽丝，10字节

/o
\i@/Dcd

在线尝试！

说明

/o
\i@/...

这只是需要十进制I / O的线性算术繁重程序的标准框架。实际的程序本身就是：

Dcd

哪个：

D    Deduplicate prime factors. Does what it sounds like: for every p^k which
     is a divisor n, this divides n by p^(k-1).
c    Push the individual prime factors of n. Since we've deduplicated them
     first, the number of factors is equal to the value we're looking for.
d    Push the stack depth, i.e. the number of unique prime factors.

— 马丁·恩德
source

3

JavaScript 45字节

*对于@SEJPM，请提供一个解释：我在这里所做的是-我从2-n开始变化（这将改变，最终将是最大的素数）-现在，如果当前数字除以ni，则只希望对其计数一次（甚至尽管它可能是2 * 2 * 2 * 3的因数-2被计数一次）-所以“ j”出现在图片中，当在函数调用中未指定j时-j将收到“ undefined”，然后当n％i == 0时，我在下一次调用中调用j = 1的函数）-然后，当j等于undefined时，我才加1，即！j + Function（n / i，i，（ j = 1或仅1））。我不会在这件事上更改i，因为它仍然可以被i再次整除（2 * 2 * 3），但是j将等于1，并且不会被视为一个因子。希望我解释得足够好。

P=(n,i=2,j)=>i>n?0:n%i?P(n,i+1):!j+P(n/i,i,1)

console.log(P(1538493)==4);
console.log(P(24)==2);
console.log(P(126)==3);
console.log(P(123456)==3);

展开摘要

如果最后一个素数非常大，它将超过最大调用堆栈数-如果它是一个问题，我可以进行迭代

— 丹尼尔·印度
source

您介意为此答案写一个解释吗？其余答案似乎都使用了通常的方法。

— SEJPM

@SEJPM我在此处添加了一些解释

— DanielIndie '17

1

仅供参考，对于大多数代码高尔夫球挑战，我们可以假定无限调用堆栈/无限资源（基本上，除非问题另有说明）。

— 乔纳森·艾伦，

3

CJam，7 5字节

感谢Martin Ender提供2个字节的折扣！

{mF,}

期望输入堆栈上的输入数字并将其替换为输出数字的匿名块（函数）。

在线尝试！或验证所有测试用例。

说明

{   }   e# Define block
 mF     e# List of (prime, exponent) pairs
   ,    e# Length

— 路易斯·门多
source

3

Brachylog，3个字节

ḋdl

在线尝试！

说明

ḋ      Prime decomposition
 d     Remove duplicates
  l    Length

— 致命
source

2

Pyth, 3 bytes

l{P

Test suite

Length (l) of set ({) of prime factors (P) of the input.

— isaacg
source

2

Husk, 3 bytes

Lup

Try it online!

Explanation

  p  -- prime factors
 u   -- unique elements
L    -- length

— ბიმო
source

2

Actually, 2 bytes

^{Yet another pretty boring answer... --- J. Allan}

yl

Try it online!

The first character can be replaced by w.

— Mr. Xcoder
source

That's enough, dude... :P

— totallyhuman

@icrieverytim I promise this is my last golfing-language answer (I only have 4 :P)

— Mr. Xcoder

2

Pyke, 3 bytes

P}l

Try it here!

— Mr. Xcoder
source

2

Python 3, 68 67 bytes

1 byte removed thanks to @Mr.Xcoder

lambda n:sum(n%k<all(k%j for j in range(2,k))for k in range(2,n+1))

This times out for the largest test cases. Try it online!

— Luis Mendo
source

67 bytes

— Mr. Xcoder

2

R + numbers, 30 14 bytes

16 bytes removed thanks to @Giuseppe

numbers::omega

Also, here is the Try it online!! link per @Giuseppe.

— Joseph Wood
source

You may omit the f=function(x) and the (x) as numbers::omega is a function already. However, as numbers is not standard for R, you should make your answer "R + numbers". Also, you should include a TIO link. Still, +1, very nice.

— Giuseppe

@Giuseppe, you are too nice. Thanks for your help. BTW, in addition to some of your insightful answers, I checked out Tips for golfing in R, as you suggested. There are some real gems there. Anywho, I will update my answer with your recommendations. Also, your MATL solution is very nice (+1 yesterday).

— Joseph Wood

NP, feel free to ping me in chat or comment on an answer of mine if you have questions.

— Giuseppe

@Giuseppe is there a meta consensus on needing to explicitly state "R + numbers"? It seems like if we state the additional package then we should be able to save the bytes of explicitly calling it with numbers::. Otherwise, to me it's the same as using an import in any other language.

— BLT

(scrolls down and sees a python example of this...) I guess I'm wondering about a broader meta consensus, then. It just sort of seems silly to me.

— BLT

1

Convex, 3 bytes

mF,

Try it online!

— GamrCorps
source

1

Pari/GP, 5 bytes

I don't know why it is called nu in Mathematica but omega in Pari/GP.

omega

Try it online!

— alephalpha
source

1

Haskell, 58 bytes

-4 bytes thanks to @Laikoni

f n=sum[1|x<-[2..n],gcd x n>1,all((>)2.gcd x)[2..x-1]]

Try it online!

Explanation

Essentially generates all primes at most as large as n and filters them for being a factor of n and then takes the length of the result.

f n=                                                   -- main function
    sum[                                             ] -- output the length of the list
        1|x<-[2..n],                                   -- consider all potential primes <=n
                                                       -- and insert 1 into the list if predicates are satisfied
                    gcd x n>1,                         -- which are a factor of n
                              all(          )[2..x-1]  -- and for which all smaller numbers satisfy
                                  (>)2.                -- 2 being larger than
                                       gcd x           -- the gcd of x with the current smaller number

— SEJPM
source

You can use sum[1|x<- ... ] instead of length.

— Laikoni

1

Japt, 5 4 bytes

â èj

Try it

Get the divisors (â) and count (è) the primes (j).

— Shaggy
source

1

ARBLE, 28 bytes

len(unique(primefactors(n)))

Try it online!

This is a very literal solution

— ATaco
source

I was looking at this and going "Hey, wait a minute, this is a snippet!" And then I see... is this supposed to be a non-esoteric language with implicit IO?!

— totallyhuman

@icrieverytim Congratulations, you have discovered one of the main reasons this language exists.

— ATaco

0

Dyalog APL, 17 bytes

⎕CY'dfns'
≢∪3pco⎕

Try it online!

— Uriel
source

0

Python 2, 63 55 bytes

^{A much more interesting answer...}

-8 bytes thanks to Jonathan Frech (use an argument with a default for the post-adjustment of the result of primes from 0 to 1 -- much better than a wrapping lambda!!)

f=lambda n,o=1:sum(n%i+f(i,0)<1for i in range(2,n))or o

A recursive function taking a positive integer, n, and returning a positive integer, the count.

Try it online! Really inefficient, don't even bother with the other test cases.

— Jonathan Allan
source

55 bytes.

— Jonathan Frech

@JonathanFrech Thanks, that is much cleaner.

— Jonathan Allan

0

J, 12 bytes

{:@$@(__&q:)

q: is J's prime exponents function, giving it the argument __ produces a matrix whose first row is all nonzero prime factors and whose 2nd row is their exponents.

We take the shape $ of that matrix -- rows by columns -- the number of columns is the answer we seek.

{: gives us the last item of this two items (num rows, num columns) list, and hence the answer.

Try it online!

— Jonah
source

0

Java (OpenJDK 9), 67 bytes

n->{int c=0,p=1;for(;p<n;)if(n%++p<1)for(c++;n%p<1;n/=p);return c;}

Try it online!

— Olivier Grégoire
source

0

Javascript ES6, 56 chars

n=>eval(`for(q=2,r=0;q<=n;++q)n%q||(n/=q,r+=!!(n%q--))`)

Test:

f=n=>eval(`for(q=2,r=0;q<=n;++q)n%q||(n/=q,r+=!!(n%q--))`)
console.log([24,126,1538493,123456].map(f)=="2,3,4,3")

Expand snippet

— Qwertiy
source

多少个素数？

你的任务：

输入：

输出：

测试用例：

得分：

MATL，4 3字节

05AB1E，2个字节

怎么样？

Mathematica，7个字节

Mathematica，21个字节

盖亚 2字节

Python 2，56个字节

视网膜，31 30字节

怎么运行的

Bash + GNU实用程序，33

说明

果冻，3 个字节

怎么样？

欧姆v2，2个字节

果冻，2个字节

爱丽丝，10字节

说明

JavaScript 45字节

CJam，7 5字节

说明

Brachylog，3个字节

说明

Pyth, 3 bytes

Husk, 3 bytes

Explanation

Actually, 2 bytes

Pyke, 3 bytes

Python 3, 68 67 bytes

R + numbers, 30 14 bytes

Convex, 3 bytes

Pari/GP, 5 bytes

Haskell, 58 bytes

Japt, 5 4 bytes

ARBLE, 28 bytes

Dyalog APL, 17 bytes

Python 2, 63 55 bytes

J, 12 bytes

Java (OpenJDK 9), 67 bytes

Javascript ES6, 56 chars