Definition

Eine quadratfreie Halbwertszeit ist eine natürliche Zahl, die das Produkt zweier unterschiedlicher Primzahlen ist.

Die Aufgabe

nZählen Sie bei einer natürlichen Zahl alle quadratfreien Halbzeiten kleiner oder gleich n.

Einzelheiten

Bitte schreiben Sie eine Funktion oder Prozedur, die einen einzelnen ganzzahligen Parameter akzeptiert und alle quadratfreien Halbzeiten zählt, die kleiner oder gleich seinem Parameter sind. Die Zählung muss entweder ein Rückgabewert eines Funktionsaufrufs sein oder in STDOUT gedruckt werden.

Wertung

Die Antwort mit der geringsten Anzahl von Zeichen gewinnt.

Im Falle eines Unentschieden werden die folgenden Kriterien der Reihe nach verwendet:

1. Größte Person

2. Beste Zeitkomplexität

3. Schlimmste Raumkomplexität

Beispiele

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

J, 50 40 38 37 Zeichen

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

Verwendungszweck:

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

Mit Dank an FUZxxl .

Leistungstest

   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 │   │
└───────┴──────┴────────┴────────┴─────┴────┴───┘

Ich bin kein Theoretiker, wie hier in der Vergangenheit gesehen wurde, aber ich denke, die zeitliche Komplexität ist so etwas wie O (n _p ² ), wobei n _p die Anzahl der Primzahlen bis einschließlich der Eingangszahl n ist. Dies basiert auf der Annahme, dass die Komplexität meiner Methode (Generieren einer sehr großen Multiplikationstabelle) die Komplexität der in J eingebauten Primgenerierungsfunktion bei weitem überwiegt.

Erläuterung

f=:3 :'...'deklariert ein (monadisches) Verb (Funktion). Die Eingabe in das Verb wird durch ydie Verbdefinition dargestellt.

p:i._1&p:yDas p:Verb ist das Mehrzweck-Primzahlverb und wird hier auf zwei verschiedene Arten verwendet: _1&p:yGibt die Anzahl der Primzahlen zurück, die geringer sind als die, die ydann für p:i.jede einzelne generiert werden. Verwendung von 10 als Eingabe:

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

(~:/**/)~generiert die Tabelle, von der ich zuvor gesprochen habe. */generiert eine Multiplikationstabelle, ~:/generiert eine ungleiche Tabelle (um die Quadrate zu eliminieren) und beide werden miteinander multipliziert. Verwenden Sie unsere vorherige Ausgabe als Eingabe:

   */~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

}.~.,Jetzt verwandeln wir die Zahlen in eine Liste, ,erhalten die eindeutigen Werte ~.und entfernen die 0 am Anfang}.

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

y<: ein Vergleich mit der ursprünglichen Eingabe, um zu überprüfen, welche Werte gültig sind:

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

+/ und summiere das dann, um die Antwort zu erhalten.

   +/1 1 0 0 0 0
2

Mathematica 65 64 55 51 47 39

Code

Im Folgenden wird die Anzahl der quadratfreien Halbzeiten kleiner oder gleich gezählt n:

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

Alle quadratfreien Semifrime-Faktoren in einer Struktur der Form: {{p,1}{q,1}} Zum Beispiel:

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

Die Routine zählt einfach die Zahlen im gewünschten Bereich, die diese Struktur von Faktoren haben.

Verwendungszweck

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

(* out *)
18

Timing: Alle angegebenen Beispiele

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

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

Timing: n = 10 ^ 6

Es dauert weniger als vier Sekunden, um die Anzahl der quadratfreien Halbprimzahlen zu zählen, die kleiner oder gleich einer Million sind.

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

Gelee , 7 Bytes

ŒcfÆf€L

Probieren Sie es online aus!

Wie es funktioniert

Œ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.

Python (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))

Bitte geben Sie einige Beispielergebnisse an, damit die Teilnehmer ihre Programme testen können.

Ruby 82

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

Demo: 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/

Online-Demo hier

Hinweis: In der obigen Demo habe ich die 420und 10000Testfälle ausgeschlossen . Aufgrund des äußerst ineffizienten Primalitätstests ist es nicht möglich, das Programm für diese Eingaben in weniger als 5 Sekunden auszuführen.

Shell, 40

#! / bin / sh

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

#old, 61
#seq $ 1 | factor | awk 'BEGIN {a = 0} NF == 3 && $ 2! = $ 3 {a ++} END {print a}'

Verwendungszweck:

$ ./count 1
0
$ ./count 420
124
$ ./count 10000
2600
$ time ./cnt.sh 1000000
209867

echte 0m23.956s
Benutzer 0m23.601s
sys 0m0.404s

Gelee , 14 13 Bytes

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

Probieren Sie es online aus!

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!

Konstruktive Kritik erwünscht!

Python 2/3 , 95 94 Bytes

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

Probieren Sie es online aus!

Gepostet in einer 6 Jahre alten Herausforderung, weil es einen neuen Python-Rekord aufstellt, eine IMO, es ist ein ziemlich interessanter Ansatz.

Erläuterung

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 Bytes

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

Probieren Sie es online aus!

Basierend auf einem 92-Byte-Golf von Value Ink. PyPy wird für die korrekte Interpretation benötigt 0or, da Standard-Python dies als Versuch einer Oktalzahl ansieht.

Stax , 8 Bytes

ߺ@N¬Që↔

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

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

Führen Sie diesen aus

Perl 6 , 58 45 Bytes

Vielen Dank an Jo King für -13 Bytes.

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

Nutzt die Tatsache aus, dass ganze Zahlen mit vier Faktoren entweder quadratfreie Halbzeiten oder perfekte Würfel sind.

Probieren Sie es online aus!

Brachylog , 7 Bytes

{≥ḋĊ≠}ᶜ

Probieren Sie es online aus!

           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.

Netzhaut , 58 Bytes

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

Probieren Sie es online aus!

Nimmt als Eingabe unär mit _als Strichmarkierung

Erläuterung

Eine Zahl ist eine quadratfreie Halbprimzahl, wenn ihr größter und kleinster Faktor, mit Ausnahme von sich selbst und 1, beide Primzahlen sind.

_
¶_$`

Nimmt die Eingabe und generiert jede unäre Zahl, die kleiner oder gleich ist, jede in einer eigenen Zeile

%(`

Dann für jede Nummer ...

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

Finden Sie den kleinsten und größten Faktor, ohne sich selbst eine 1 ...

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

und zähle die Anzahl von ihnen, die Primzahl ist. Da der kleinste Faktor eine Primzahl sein muss, gibt dies 1 oder 2 zurück

2

Zählen Sie die Gesamtzahl der 2er

Python 2 , 105 104 Bytes

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

Probieren Sie es online aus!

1 Byte danke an Tintenfisch 🦑

Ruby -rprime , 64 Bytes

Ich weiß, dass es hier eine andere Ruby-Lösung gibt, aber ich wollte sie nicht mit Kommentaren überhäufen, da sie 2012 beantwortet wurde ... und wie sich herausstellt, zählt die Verwendung eines Programmflags sie als eine andere Sprache , also denke ich das technisch ist sowieso nicht "Ruby".

Probieren Sie es online aus!

Erläuterung

->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), Zeichen 26, Bytes 52

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

Prüfung:

  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

Dies ist eine längere Alternative (59 Zeichen, die ich bevorzugen würde)

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

Prüfung:

  h 1000000
209867