วิธีหนึ่งในการแทนจำนวนธรรมชาติคือการคูณเลขชี้กำลังของจำนวนเฉพาะ ตัวอย่างเช่น 6 สามารถแทนด้วย 2 ^ 1 * 3 ^ 1 และ 50 สามารถแทนได้ด้วย 2 ^ 1 * 5 ^ 2 (โดยที่ ^ หมายถึง exponention) จำนวนของจำนวนเฉพาะในการเป็นตัวแทนนี้สามารถช่วยในการกำหนดว่ามันจะสั้นกว่าที่จะใช้วิธีการเป็นตัวแทนนี้เมื่อเทียบกับวิธีการอื่น ๆ แต่เนื่องจากฉันไม่ต้องการคำนวณสิ่งเหล่านี้ด้วยตนเองฉันต้องการโปรแกรมที่จะทำเพื่อฉัน อย่างไรก็ตามเนื่องจากฉันจะต้องจำโปรแกรมจนกว่าฉันจะถึงบ้านจึงต้องสั้นที่สุด

งานของคุณ:

เขียนโปรแกรมหรือฟังก์ชั่นเพื่อกำหนดจำนวนช่วงเวลาที่แตกต่างกันในการแทนตัวเลข

การป้อนข้อมูล:

จำนวนเต็ม 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

เกณฑ์การให้คะแนน:

นี่คือโค้ดกอล์ฟคะแนนต่ำสุดเป็นไบต์ชนะ!

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)

05AB1E , 2 ไบต์

^{อีกคำตอบที่น่าเบื่อ ...}

fg

โปรแกรมเต็มรูปแบบที่รับอินพุตตัวเลขและพิมพ์ผลลัพธ์

ลองออนไลน์!

อย่างไร?

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

Mathematica ขนาด 7 ไบต์

PrimeNu

ใช่มีในตัว

Mathematica ขนาด 21 ไบต์

Length@*FactorInteger

ทางยาวรอบ

Gaia 2 ไบต์

^{อีกคำตอบที่น่าเบื่อ ... --- เจอัลลัน}

ḋl

ลองออนไลน์!

• ḋ- ตัวประกอบนายกรัฐมนตรีเป็น[นายกตัวแทน]คู่

• l - ความยาว.

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]

เรติน่า31 31ไบต์

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

อินพุตไม่พร้อมกัน

ขอบคุณ @MartinEnder สำหรับการเล่นกอล์ฟขนาด 1 ไบต์!

ลองออนไลน์! (รวมโปรแกรมแปลงทศนิยมเป็นทศนิยม)

มันทำงานอย่างไร

เนื่องจากโปรแกรมประกอบด้วย regex เพียงตัวเดียวพร้อมด้วย&ตัวปรับแต่งจอประสาทตา Retina จึงนับจำนวนการจับคู่ที่เหลื่อมซ้อนกัน การป้อนข้อมูลจะถือว่าประกอบด้วยการทำซ้ำnจาก1และไม่มีอะไรอื่น

หัวลูกเชิงลบ

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

การแข่งขันในสถานที่ระหว่าง1 's ที่ไม่ได้ตามมาด้วยสองคนหรือมากกว่า1 ' s ( 11+) ตามด้วยหนึ่งหรือมากกว่าหนึ่งซ้ำของจำนวนเงินเดียวกันของ1 's ( \1+) ตามด้วยในตอนท้ายของการป้อนข้อมูล ( $)

ใด ๆ จำนวนคอมโพสิตABกับA, B> 1สามารถเขียนเป็นขซ้ำของซ้ำของ1เพื่อให้ตรงกับ lookahead เฉพาะสถานที่ตั้งตามหน้าซ้ำ 1ที่p = 1หรือหน้าเป็นสำคัญ

regex

(11+)$

ทำให้แน่ใจว่าp> 1โดยกำหนดอย่างน้อยสอง1 's (11+ ) และเก็บหางของ1ในกลุ่มการจับภาพที่สอง ( \2)

ในที่สุดมองในแง่บวก

(?<=^\2+)

ตรวจสอบว่าอินพุตทั้งหมดประกอบด้วยการเกิดขึ้นของkp ( k ≥ 1 ) ของ1โดยตรวจสอบว่าpหารอินพุต

ดังนั้นการแข่งขันแต่ละสอดคล้องกับเอกลักษณ์สำคัญหารพี

ยูทิลิตี Bash + GNU, 33

• บันทึก 1 ไบต์ขอบคุณ @Dennis

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

เยลลี่ 3 ไบต์

^{คำตอบที่น่าเบื่อ ...}

ÆFL

ลิงก์ monadic ที่ใช้ตัวเลขและส่งคืนตัวเลข

ลองออนไลน์!

อย่างไร?

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

โอห์ม v2 , 2 ไบต์

ml

ลองออนไลน์!

บิวด์อินทั้งสองอยู่ติดกันในเอกสารคู่มือ lol

วุ้น 2 ไบต์

^{อีกคำตอบที่น่าเบื่อ ... --- เจอัลลัน}

Æv

ลองออนไลน์!

แบบในตัว

อลิซ 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.

JavaScript 45 ไบต์

* สำหรับ @SEJPM ขอคำอธิบาย: สิ่งที่ฉันกำลังทำอยู่นี่คือสิ่งนี้ฉันจะเริ่มจาก 2 - n (ซึ่งการเปลี่ยนแปลงและในที่สุดจะเป็นปัจจัยสำคัญที่สุด) - ตอนนี้หากจำนวนปัจจุบันหารหาร ni ต้องการนับเพียงครั้งเดียว (แม้ แม้ว่ามันจะเป็นปัจจัยของ 2 * 2 * 2 * 3 - 2 นับเป็นครั้งเดียว) ดังนั้น "j" จึงมาที่รูปภาพเมื่อ j ไม่ได้ระบุไว้ในการเรียกของ funcion - j จะได้รับค่าของ " ไม่ได้กำหนด ", และเมื่อ n% i == 0 จากนั้นฉันเรียกใช้ฟังก์ชันด้วย j = 1 ในการโทรครั้งถัดไป) - แล้วฉันจะเพิ่ม 1 เมื่อ j เท่ากับไม่ได้กำหนดซึ่งก็คือ! j + ฟังก์ชั่น (n / i, i, ( j = 1 หรือเพียง 1)) ฉันไม่เปลี่ยนฉันในเรื่องนี้เพราะมันอาจจะยังคงถูกหารด้วยฉันอีกครั้ง (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);

ถ้านายกคนสุดท้ายมีขนาดใหญ่กว่ามันจะมีการเรียก max stack - หากเป็นปัญหาฉันสามารถทำซ้ำได้

CJam , 7 5 ไบต์

ขอบคุณ Martin Ender สำหรับการปิด 2 ไบต์!

{mF,}

บล็อกแบบไม่ระบุชื่อ (ฟังก์ชัน) ที่คาดว่าจะมีหมายเลขอินพุตในสแต็กและแทนที่ด้วยหมายเลขเอาต์พุต

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

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

Brachylogขนาด 3 ไบต์

ḋdl

ลองออนไลน์!

คำอธิบาย

ḋ      Prime decomposition
 d     Remove duplicates
  l    Length

Pyth, 3 bytes

l{P

Test suite

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

Husk, 3 bytes

Lup

Try it online!

Explanation

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

Actually, 2 bytes

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

yl

Try it online!

The first character can be replaced by w.

Pyke, 3 bytes

P}l

Try it here!

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!

R + numbers, 30 14 bytes

16 bytes removed thanks to @Giuseppe

numbers::omega

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

Convex, 3 bytes

mF,

Try it online!

Pari/GP, 5 bytes

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

omega

Try it online!

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

Japt, 5 4 bytes

â èj

Try it

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

ARBLE, 28 bytes

len(unique(primefactors(n)))

Try it online!

This is a very literal solution

Dyalog APL, 17 bytes

⎕CY'dfns'
≢∪3pco⎕

Try it online!

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.

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!

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!

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