Liczba sferyczna to liczba, która jest wynikiem dokładnie trzech różnych liczb pierwszych. Pierwsze kilka liczb sferycznych to 30, 42, 66, 70, 78, 102, 105, 110, 114. Jest to sekwencja A007304 w OEIS.

Twoje zadanie:

Napisz program lub funkcję, aby ustalić, czy wprowadzona liczba całkowita jest liczbą sferyczną.

Wkład:

Liczba całkowita z zakresu od 0 do 10 ^ 9, która może, ale nie musi, być liczbą sferyczną.

Wydajność:

Wartość prawda / fałsz wskazująca, czy dane wejściowe są liczbą sferyczną.

Przykłady:

30  -> true
121 -> false
231 -> true
154 -> true
4   -> false
402 -> true
79  -> false
0   -> false
60  -> false
64  -> false
8   -> false
210 -> false

Punktacja:

To jest code-golf , wygrywa najkrótszy kod w bajtach.

Brachylog , 6 3 bajty

ḋ≠Ṫ

Wypróbuj online!

Wyjaśnienie

ḋ        The prime factorization of the Input…
 ≠       …is a list of distinct elements…
  Ṫ      …and there are 3 elements

bash, 43 bajty

factor $1|awk '{print $2-$3&&$3-$4&&NF==4}'

Wypróbuj online!

Wprowadzanie za pomocą argumentu wiersza poleceń, danych wyjściowych 0lub standardowego wyjścia 1.

Dość oczywiste; analizuje dane wyjściowe w factorcelu sprawdzenia, czy pierwszy i drugi czynnik są różne, drugi i trzeci są różne (są posortowane, więc to wystarczy), i są cztery pola (liczba wejściowa i trzy czynniki).

MATL , 7 bajtów

_YF7BX=

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

_YF   % Implicit input. Nonzero exponents of prime-factor decomposition
7     % Push 7
B     % Convert to binary: gives [1 1 1] 
X=    % Is equal? Implicit display

C, 88 78 126 58 77 73 + 4 ( lm) = 77 bajtów

l,j;a(i){for(l=1,j=0;l++<i;fmod(1.*i/l,l)?i%l?:(i/=l,j++):(j=9));l=i==1&&j==3;}

Niegolfowane komentarzem wyjaśnienie:

look, div; //K&R style variable declaration. Useful. Mmm.

a ( num ) { // K&R style function and argument definitions.

  for (
    look = 1, div = 0; // initiate the loop variables.
    look++ < num;) // do this for every number less than the argument:

      if (fmod(1.0 * num / look, look))
      // if num/look can't be divided by look:

        if( !(num % look) ) // if num can divide look
          num /= look, div++; // divide num by look, increment dividers
      else div = 9;
      // if num/look can still divide look
      // then the number's dividers aren't unique.
      // increment dividers number by a lot to return false.

  // l=j==3;
  // if the function has no return statement, most CPUs return the value
  // in the register that holds the last assignment. This is equivalent to this:
  return (div == 3);
  // this function return true if the unique divider count is 3
}

Wypróbuj online!

CJam , 11 bajtów

rimFz1=7Yb=

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

Na podstawie mojej odpowiedzi MATL.

ri    e# Read integer
mF    e# Factorization with exponents. Gives a list of [factor exponent] lists
z     e# Zip into a list of factors and a list of exponents
1=    e# Get second element: list of exponents
7     e# Push 7
Yb    e# Convert to binary: gives list [1 1 1]
=     e# Are the two lists equal? Implicitly display

Galaretki , 8 bajtów

ÆEḟ0⁼7B¤

Wypróbuj online!

Wykorzystuje algorytm Luisa Mendo.

Wyjaśnienie:

ÆEḟ0⁼7B¤
ÆE       Prime factor exponents
  ḟ0     Remove every 0
    ⁼7B¤ Equal to 7 in base 2?

Łuska , 6 bajtów

≡ḋ3Ẋ≠p

Wypróbuj online!

Zwraca 1 dla liczb sferycznych i 0 w przeciwnym razie.

Wyjaśnienie

≡ḋ3Ẋ≠p    Example input: 30
     p    Prime factors: [2,3,5]
   Ẋ≠     List of absolute differences: [1,2]
≡         Is it congruent to...       ?
 ḋ3           the binary digits of 3: [1,1]

W ostatnim fragmencie zgodność między dwiema listami oznacza tę samą długość i taki sam rozkład wartości prawdy / fałszu. W tym przypadku sprawdzamy, czy nasz wynik składa się z dwóch prawdziwych (tj. Niezerowych) wartości.

Mathematica, 31 bajtów

SquareFreeQ@#&&PrimeOmega@#==3&

Galaretka , 6 bajtów

ÆE²S=3

Wypróbuj online!

Jak to działa

ÆE²S=3  Main link. Argument: n

ÆE      Compute the exponents of n's prime factorization.
  ²     Take their squares.
   S    Take the sum.
    =3  Test the result for equality with 3.

05AB1E , 7 5 bajtów

ÓnO3Q

Wypróbuj online!

Wykorzystuje algorytm Dennisa.

Właściwie 7 bajtów

w♂N13α=

Wypróbuj online!

Wyjaśnienie:

w♂N13α=
w       Push [prime, exponent] factor pairs
 ♂N     Map "take last element"
   1    Push 1
    3   Push 3
     α  Repeat
      = Equal?

Haskell , 59 bajtów

f x=7==sum[6*0^(mod(div x a)a+mod x a)+0^mod x a|a<-[2..x]]

Wypróbuj online!

J , 15 bajtów

7&(=2#.~:@q:)~*

Wypróbuj online!

Wyjaśnienie

7&(=2#.~:@q:)~*  Input: integer n
              *  Sign(n)
7&(         )~   Execute this Sign(n) times on n
                 If Sign(n) = 0, this returns 0
          q:       Prime factors of n
       ~:@         Nub sieve of prime factors
    2#.            Convert from base 2
   =               Test if equal to 7

Dyalog APL, 26 bajtów

⎕CY'dfns'
((≢,∪)≡3,⊢)3pco⎕

Wypróbuj online!

Ruby, 81 49 46 bajtów

Zawiera 6 bajtów dla opcji wiersza poleceń -rprime.

->n{n.prime_division.map(&:last)==[1]*3}

Wypróbuj online!

Python 3 , 54 53 bajtów

lambda n:sum(1>>n%k|7>>k*k%n*3for k in range(2,n))==6

Dzięki @xnor za grę w golfa na 1 bajcie!

Wypróbuj online!

C, 91 102 bajtów, tym razem poprawiony (ponownie), grał w golfa i tym razem przetestował:

<strike>s(c){p,f,d;for(p=2,f=d=0;p<c&&!d;){if(c%p==0){c/=p;++f;if(c%p==0)d=1;}++p;}c==p&&f==2&&!d;}</strike>
s(c){int p,f,d;for(p=2,f=d=0;p<c&&!d;){if(c%p==0){c/=p;++f;if(c%p==0)d=1;}++p;}return c==p&&f==2&&!d;}

/ * Działa to również w 93 bajtach, ale ponieważ zapomniałem o standardowych regułach blokujących domyślny typ int dla zmiennych dynamicznych oraz o niedozwoleniu niejawnych wartości zwrotnych bez przypisań, nie zamierzam tego robić:

p,f,d;s(c){for(p=2,f=d=0;p<c&&!d;){if(c%p==0){c/=p;++f;if(c%p==0)d=1;}++p;}p=c==p&&f==2&&!d;}

(Kto powiedział, że wiem coś o C? ;-)

Oto ramka testowa ze skryptem powłoki w komentarzach:

/* betseg's program for sphenic numbers from 
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h> /* compile with -lm */

/* l,j;a(i){for(l=1,j=0;l<i;i%++l?:(i/=l,j++));l=i==1&&j==3;} */
#if defined GOLFED
l,j;a(i){for(l=1,j=0;l++<i;fmod((float)i/l,l)?i%l?:(i/=l,j++):(j=9));l=i==1&&j==3;}
#else 
int looker, jcount;
int a( intval ) {
  for( looker = 1, jcount = 0; 
    looker++ < intval; 
    /* Watch odd intvals and even lookers, as well. */
    fmod( (float)intval/looker, looker )  
      ? intval % looker /* remainder? */
        ? 0 /* dummy value */
        : ( inval /= looker, jcount++ /* reduce the parameter, count factors */ ) 
      : ( jcount = 9 /* kill the count */ ) 
  )
    /* empty loop */;
  looker = intval == 1 && jcount == 3; /* reusue looker for implicit return value */
}
#endif

/* for (( i=0; $i < 100; i = $i + 1 )) ; do echo -n at $i; ./sphenic $i ; done */

Pożyczyłem poprzednią odpowiedź betsega, aby przejść do mojej wersji.

To jest moja wersja algorytmu betsega, którą grałem w golfa, aby dostać się do mojego rozwiązania:

/* betseg's repaired program for sphenic numbers
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int sphenic( int candidate )
{
  int probe, found, dups;
  for( probe = 2, found = dups = 0; probe < candidate && !dups; /* empty update */ ) 
  { 
    int remainder = candidate % probe;
    if ( remainder == 0 ) 
    {
      candidate /= probe;
      ++found;
      if ( ( candidate % probe ) == 0 )
        dups = 1;
    }
    ++probe;
  } 
  return ( candidate == probe ) && ( found == 2 ) && !dups;
}

int main( int argc, char * argv[] ) { /* Make it command-line callable: */
  int parameter;
  if ( ( argc > 1 ) 
       && ( ( parameter = (int) strtoul( argv[ 1 ], NULL, 0 ) ) < ULONG_MAX ) ) {
    puts( sphenic( parameter ) ? "true" : "false" );
  }
  return EXIT_SUCCESS; 
}

/* for (( i=0; $i < 100; i = $i + 1 )) ; do echo -n at $i; ./sphenic $i ; done */

Pyth, 9 bajtów

&{IPQq3lP

Wypróbuj tutaj.

JavaScript (ES6), 87 bajtów

n=>(a=(p=i=>i>n?[]:n%i?p(i+1):[i,...p(i,n/=i)])(2)).length==3&&a.every((n,i)=>n^a[i+1])

Przykładowy fragment kodu:

f=
n=>(a=(p=i=>i>n?[]:n%i?p(i+1):[i,...p(i,n/=i)])(2)).length==3&&a.every((n,i)=>n^a[i+1])

for(k=0;k<10;k++){
  v=[30,121,231,154,4,402,79,0,60,64][k]
  console.log(`f(${v}) = ${f(v)}`)
}

Python 2 , 135 121 bajtów

• Dość długo, ponieważ obejmuje to wszystkie procedury: sprawdzanie liczby pierwszej, czynniki uzyskiwania liczby pierwszej i sprawdzanie stanu liczby kul.

lambda x:(lambda t:len(t)>2and t[0]*t[1]*t[2]==x)([i for i in range(2,x)if x%i<1and i>1and all(i%j for j in range(2,i))])

Wypróbuj online!

Python 2 , 59 bajtów

lambda x:6==sum(5*(x/a%a+x%a<1)+(x%a<1)for a in range(2,x))

Wypróbuj online!

J, 23 bajty

0:`((~.-:]*.3=#)@q:)@.*

Wypróbuj online!

Obsługa 8 i 0 w zasadzie zrujnowała tę ...

q: daje ci wszystkie czynniki pierwsze, ale nie radzi sobie z 0. reszta po prostu mówi „unikalne czynniki powinny być równe czynnikom” i „ich liczba powinna wynosić 3”

Japt , 14 bajtów

k
k@è¥X ÉÃl ¥3

Wypróbuj online!

Mathematica, 44 bajty

Plus@@Last/@#==Length@#==3&@FactorInteger@#&

Wypróbuj online!

VB.NET (.NET 4.5), 104 bajty

Function A(n)
For i=2To n
If n Mod i=0Then
A+=1
n\=i
End If
If n Mod i=0Then A=4
Next
A=A=3
End Function

Używam funkcji VB, gdzie nazwa funkcji jest również zmienną. Pod koniec wykonania, ponieważ nie ma instrukcji return, zamiast tego przekaże wartość „funkcji”.

To ostatnie A=A=3można wymyślić return (A == 3)w językach opartych na C.

Zaczyna się od 2 i iteracyjnie ściąga liczby pierwsze. Ponieważ zaczynam od najmniejszych liczb pierwszych, nie można go podzielić przez liczbę zespoloną.

Spróbuje po raz drugi podzielić przez tę samą liczbę pierwszą. Jeśli tak (np. Jak 60 dzieli się dwa razy przez 2), ustawi liczbę liczb pierwszych na 4 (powyżej maksimum dozwolonego dla liczby sferycznej).

Wypróbuj online!

Dyalog APL, 51 49 48 46 45 43 bajtów

1∊((w=×/)∧⊢≡∪)¨(⊢∘.,∘.,⍨){⍵/⍨2=≢∪⍵∨⍳⍵}¨⍳w←⎕

Wypróbuj online! (zmodyfikowany, aby mógł działać na TryAPL)

Chciałem przesłać taki, który nie opiera się w ogóle na przestrzeni nazw dfns, nawet jeśli jest długi .

J, 15 14 19 bajtów

Poprzednia próba: 3&(=#@~.@q:)~*

Obecna wersja: (*/*3=#)@~:@q: ::0:

Jak to działa:

(*/*3=#)@~:@q: ::0:  Input: integer n
               ::0:  n=0 creates domain error in q:, error catch returns 0
            q:       Prime factors of n
         ~:@         Nub sieve of prime factors 1 for first occurrence 0 for second
(*/*3=#)@            Number of prime factors is equal to 3, times the product across the nub sieve (product is 0 if there is a repeated factor or number of factors is not 3)

Dotyczy to przypadków 0, 8 i 60, których poprzednia wersja nie miała.

Mathematica, 66 57 bajtów

Length@#1==3&&And@@EqualTo[1]/@#2&@@(FactorInteger@#)&

Definiuje anonimową funkcję.

to transpozycja .

Wyjaśnienie

FactorIntegerpodaje listę par czynników i ich wykładników. Np FactorInteger[2250]=={{2,1},{3,2},{5,3}}. Zostało to transponowane w celu ułatwienia użytkowania i wprowadzone do funkcji Length@#1==3&&And@@EqualTo[1]/@#2&. Pierwsza część Length@#1==3sprawdza, czy istnieją 3 unikalne czynniki, a druga And@@EqualTo[1]/@#2sprawdza , czy wszystkie wykładniki mają wartość 1.

PHP, 66 bajtów:

for($p=($n=$a=$argn)**3;--$n;)$a%$n?:$p/=$n+!++$c;echo$c==7&$p==1;

Uruchom jako potok z -nRlub spróbuj online .

Nieskończona pętla dla 0; włóż $n&&przed, --$naby naprawić.

awaria

for($p=($n=$a=$argn)**3;    # $p = argument**3
    --$n;)                  # loop $n from argument-1
    $a%$n?:                     # if $n divides argument
        $p/=$n                      # then divide $p by $n
        +!++$c;                     # and increment divisor count
echo$c==7&$p==1;            # if divisor count is 7 and $p is 1, argument is sphenic

przykładowy
argument = 30:
czynniki pierwsze są 2, 3a 5
innymi dzielnikami są 1, 2 * 3 = 6, 2 * 5 = 10i 3 * 5 = 15
ich iloczyn: 1*2*3*5*6*10*15is 27000==30**3

Python 99 bajtów

def s(n):a,k=2,0;exec('k+=1-bool(n%a)\nwhile not n%a:n/=a;k+=10**9\na+=1\n'*n);return k==3*10**9+3

Pierwsze zgłoszenie. Wybacz mi, jeśli zrobiłem coś złego. Trochę głupie, liczy liczbę czynników n, a następnie liczba razy njest podzielna przez każdy (przez dodanie 10 ** 9).

Jestem pewien, że istnieje kilka prostych sposobów na odcięcie ~ 10-20 znaków, ale nie zrobiłem tego.

Jest to również niewyobrażalnie wolne przy 10 ** 9. Mogą być wykonane w porządku , zmieniając '...a+=1\n'*nsię '...a+=1\n'*n**.5, jak tylko trzeba iść do pierwiastka kwadratowego n.