Un nombre sphénique est un nombre qui est le produit d'exactement trois nombres premiers distincts. Les premiers nombres sphéniques le sont 30, 42, 66, 70, 78, 102, 105, 110, 114. Il s'agit de la séquence A007304 dans l'OEIS.

Ta tâche:

Écrivez un programme ou une fonction pour déterminer si un entier entré est un nombre Sphenic.

Contribution:

Un entier compris entre 0 et 10 ^ 9, qui peut ou non être un nombre sphénique.

Sortie:

Une valeur de vérité / fausse indiquant si l'entrée est un nombre sphénique.

Exemples:

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

Notation:

C'est le code-golf , le code le plus court en octets gagne.

Brachylog , 6 3 octets

ḋ≠Ṫ

Essayez-le en ligne!

Explication

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

bash, 43 octets

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

Essayez-le en ligne!

Entrée via l'argument de ligne de commande, sorties 0 ou 1vers stdout.

Assez explicite; analyse la sortie de factorpour vérifier que les premier et deuxième facteurs sont différents, les deuxième et troisième sont différents (ils sont triés, donc cela suffit), et il y a quatre champs (le numéro d'entrée et les trois facteurs).

MATL , 7 octets

_YF7BX=

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

_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 octets

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;}

Explication commentée non golfée:

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
}

Essayez-le en ligne!

CJam , 11 octets

rimFz1=7Yb=

Essayez-le en ligne!Ou vérifiez tous les cas de test .

Explication

Basé sur ma réponse 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

Gelée , 8 octets

ÆEḟ0⁼7B¤

Essayez-le en ligne!

Utilise l'algorithme de Luis Mendo.

Explication:

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

Husk , 6 octets

≡ḋ3Ẋ≠p

Essayez-le en ligne!

Renvoie 1 pour les nombres sphéniques et 0 sinon.

Explication

≡ḋ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]

Dans le dernier passage, la congruence entre deux listes signifie avoir la même longueur et la même distribution de valeurs véridiques / fausses. Dans ce cas, nous vérifions que notre résultat est composé de deux valeurs véridiques (c'est-à-dire non nulles).

Mathematica, 31 octets

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

Gelée , 6 octets

ÆE²S=3

Essayez-le en ligne!

Comment ça marche

Æ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 octets

ÓnO3Q

Essayez-le en ligne!

Utilise l'algorithme de Dennis.

En fait , 7 octets

w♂N13α=

Essayez-le en ligne!

Explication:

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

Haskell , 59 octets

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

Essayez-le en ligne!

J , 15 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Rubis, 81 49 46 octets

Comprend 6 octets pour les options de ligne de commande -rprime.

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

Essayez-le en ligne!

Python 3 , 54 53 octets

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

Merci à @xnor d'avoir joué au golf sur 1 octet!

Essayez-le en ligne!

C, 91 102 octets, corrigé (encore), joué au golf et testé en temps réel:

<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;}

/ * Cela fonctionne également en 93 octets, mais puisque j'ai oublié les règles standard interdisant le type int par défaut sur les variables dynamiques, et que les valeurs de retour implicites ne sont pas autorisées sans affectations, je ne vais pas le prendre:

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;}

(Qui a dit que je savais quelque chose sur C? ;-)

Voici le cadre de test avec le script shell dans les commentaires:

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

J'ai emprunté la réponse précédente de betseg pour accéder à ma version.

Voici ma version de l'algorithme de betseg, sur laquelle j'ai joué pour arriver à ma solution:

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

&{IPQq3lP

Essayez-le ici.

Javascript (ES6), 87 octets

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

Exemple d'extrait de code:

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 octets

• Assez longtemps puisque cela inclut toutes les procédures: prime-check, obtention des facteurs premiers et vérification de la condition du numéro de sphère.

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

Essayez-le en ligne!

Python 2 , 59 octets

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

Essayez-le en ligne!

J, 23 octets

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

Essayez-le en ligne!

Gérer 8 et 0 a ruiné celui-ci ...

q: vous donne tous les facteurs premiers, mais ne gère pas 0. le reste dit simplement "les facteurs uniques doivent être égaux aux facteurs" et "le nombre d'entre eux doit être 3"

Japt , 14 octets

k
k@è¥X ÉÃl ¥3

Essayez-le en ligne!

Mathematica, 44 octets

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

Essayez-le en ligne!

VB.NET (.NET 4.5), 104 octets

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

J'utilise la fonctionnalité de VB où le nom de la fonction est également une variable. À la fin de l'exécution, puisqu'il n'y a pas de déclaration de retour, elle transmettra à la place la valeur de la «fonction».

Le dernier A=A=3peut être pensé return (A == 3)dans les langages basés sur C.

Commence à 2 et arrache les nombres premiers de manière itérative. Puisque je commence avec les plus petits nombres premiers, il ne peut pas être divisé par un nombre composite.

Va essayer une deuxième fois de diviser par le même nombre premier. Si c'est le cas (par exemple, comment 60 est divisé deux fois par 2), il définira le nombre de nombres premiers à 4 (au-dessus du maximum autorisé pour un nombre sphénique).

Essayez-le en ligne!

Dyalog APL, 51 49 48 46 45 43 octets

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

Essayez-le en ligne! (modifié pour pouvoir fonctionner sur TryAPL)

Je voulais en soumettre un qui ne repose pas sur l'espace de noms dfns que ce soit, même s'il est long .

J, 15 14 19 octets

Tentative précédente: 3&(=#@~.@q:)~*

Version actuelle: (*/*3=#)@~:@q: ::0:

Comment ça marche:

(*/*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)

Cela passe pour les cas 0, 8 et 60, ce que la version précédente ne faisait pas.

Mathematica, 66 57 octets

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

Définit une fonction anonyme.

est Transpose .

Explication

FactorIntegerdonne une liste de paires de facteurs et de leurs exposants. Par exemple FactorInteger[2250]=={{2,1},{3,2},{5,3}}. Ceci est transposé pour la facilité d'utilisation et alimenté la fonction Length@#1==3&&And@@EqualTo[1]/@#2&. La première partie, Length@#1==3vérifie qu'il existe 3 facteurs uniques, tandis que la seconde, And@@EqualTo[1]/@#2vérifie que tous les exposants sont 1.

PHP, 66 octets:

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

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

Boucle infinie pour 0; insérer $n&&avant --$nde fixer.

panne

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

exemple d'
argument = 30: les
facteurs premiers sont 2, 3et les 5
autres diviseurs sont 1, 2 * 3 = 6, 2 * 5 = 10et 3 * 5 = 15
leur produit: 1*2*3*5*6*10*15est 27000==30**3

Python 99 octets

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

Première soumission. Pardonnez-moi si j'ai fait quelque chose de mal. Un peu idiot, compte le nombre de facteurs de n, puis le nombre de fois nest divisible par chacun (en ajoutant 10 ** 9).

Je suis presque sûr qu'il existe quelques moyens simples de couper environ 10 à 20 caractères, mais je ne l'ai pas fait.

De plus, cela est incroyablement lent à 10 ** 9. Pourrait être rendu correct en changeant '...a+=1\n'*nen '...a+=1\n'*n**.5, car nous avons seulement besoin d'aller à la racine carrée de n.