Est-ce un numéro Sphenic?

29

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.

code-golf  number  decision-problem  primes 
— Gryphon - Rétablir Monica
source
Est 60un nombre sphénique? 2 × 2 × 3 × 5
— Erik the Outgolfer du
1
@EriktheOutgolfer ce n'est pas le produit de 3 nombres premiers distincts cependant, c'est le produit de 3 nombres premiers distincts et 1 nombre dupliqué.
— Rɪᴋᴇʀ
1
@Riker Je ne sais pas vraiment si "3 nombres premiers distincts" signifie "3 nombres premiers qui sont tous distincts" ou "lorsqu'ils ne sont pas unifiés, il devrait rester 3 nombres premiers". EDIT: Oh je vois, 60n'est pas un nombre sphénique. (en attente de clarification OP)
— Erik the Outgolfer
@EriktheOutgolfer Selon la définition des nombres sphéniques, 60 n'en fait pas partie. Je ne sais cependant pas si 60 est valable pour ce challenge.
— Wheat Wizard
@WheatWizard, 60 n'est pas un nombre sphénique (par exemple sortie / retour falsy).
— Gryphon - Rétablir Monica

Réponses:

7

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
— Fatalize
source
2
Et puis il y a la seule langue qui a une fonction intégrée ≠.
— Erik the Outgolfer
Et le intégré Ṫaussi.
— Zacharý
1
@ Zacharý Ṫn'est pas vraiment un prédicat intégré; c'est une variable intégrée: une liste de 3 éléments variables. C'est une variable précontrainte assez utile dans de nombreux défis différents.
— Fatalize
Félicitations pour la réponse la plus courte.
— Gryphon - Rétablir Monica le
11

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

— Poignée de porte
source
11

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
— Luis Mendo
source
@Suever J'y pensais, mais la sortie fausse devient plus laide (soit vide avec erreur ou un tableau avec des zéros). Je ne sais pas si je devrais ...
— Luis Mendo
4
X=est le bâti le plus triste que j'aie jamais vu.
— Erik the Outgolfer
9

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!

— betseg
source
1
Considérez i*1.0/lau lieu du plâtre de flotter. (Et puisque l, jils sont globaux, ils sont initialisés à 0 gratuitement, vous n'avez pas besoin de le faire si la fonction n'est appelée qu'une seule fois. Je ne sais pas quelle est la règle pour cela.)
— Mat
— plafondcat
5

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
— Luis Mendo
source
4

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

— Leo
source
4

Mathematica, 31 octets

SquareFreeQ@#&&PrimeOmega@#==3&
— Martin
source
Étant donné que vous testez déjà la non-carré, PrimeNufera aussi bien PrimeOmegaet est plus court.
— Mark S.
4

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.
— Dennis
source
2

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
— miles
source
Très belle utilisation de ~: et #. Une alternative pourrait être (7 & (= #. @ ~: @Q:) ~ *) que je trouve un peu plus facile à lire, mais qui n'est pas plus courte.
— bob
2

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!

— Dennis
source
Vous pouvez vérifier l'absence de carré avec k*k%nplutôt quen%k**2
— xnor
Bon, je n'ai besoin que d'un seul échec. Merci!
— Dennis
2

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 */
— Joel Rees
source
Répond-il à la question, maintenant?
— Joel Rees
Oui. Insérer ce lien à la réponse de betseg: [betseg's answer](https://codegolf.stackexchange.com/a/135203/65836). Vous pouvez également cliquer sur modifier sa réponse pour lui suggérer une modification, si vous le souhaitez, qui comprendrait l'explication - aucune promesse quant à son approbation ou non.
— Stephen
Je suis ici maintenant, et j'ai corrigé mon programme, il est à 87 octets maintenant; mais votre programme semble bon aussi.
— betseg
@betseg Il est intéressant que vous utilisiez cette fois la virgule flottante. Oh, et merci de me laisser emprunter votre algorithme. ;-)
— Joel Rees
@JoelRees j'ai ajouté une explication à ma réponse, aussi votre réponse a un problème je pense? cela ne semble pas fonctionner correctement: Essayez-le en ligne
— betseg
1

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)}`)
}
Développer l'extrait

— Herman L
source
1

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!

— officialaimm
source
1

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"

— Jonas
source
Cela échoue pour l'entrée60
— Conor O'Brien
@ ConorO'Brien merci. Voir mon montage - la correction de 60 a aidé , mais je me suis rendu compte que je ne gérais pas non plus correctement 0, et que cela faisait plus que doubler les octets
— Jonah
La dernière était mon idée originale, et cela échoue 8.
— Conor O'Brien
J'ai (6=]#@,~.)@q:comme solution possible
— Conor O'Brien
@ ConorO'Brien ah bon point sur 8. le vôtre échouera pour 0, cependant.
— Jonah
1

Japt , 14 octets

k
k@è¥X ÉÃl ¥3

Essayez-le en ligne!

— Justin Mariner
source
@Oliver Cela entraînerait le passage d'une fonction à Number.k(), qui n'aurait aucun effet et vérifierait simplement si l'entrée a 3 facteurs premiers, pas 3 facteurs premiers distincts . Cela signifierait 8(avec trois facteurs premiers :)2, 2, 2 passerait bien qu'il ne soit pas dans A007304
— Justin Mariner
Ah, tu as raison. J'allais juste par les cas de test.
— Oliver
@Oliver Ouais, cela m'a vraiment fait une boucle lorsque je travaille sur cette solution. Je viens d'ajouter 8aux cas de test pour cette raison.
— Justin Mariner
1

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!

— Brian J
source
1

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 .

— Zacharý
source
1

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.

— bob
source
1
pourquoi pas 3 = # ~ .q: pour 7 caractères? D'une session J 3 = # ~ .q: 30 ==> 1 et 3 = # ~ .q: 20 ==> 0
— Richard Donovan
Richard, votre suggestion donne un faux positif pour n = 60 et crée une erreur de domaine pour n = 0, mais ma version précédente a également échoué pour n = 60. Votre commentaire m'a incité à rechercher une solution correcte!
— bob
0

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.

— DanTheMan
source
0

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

— Titus
source
0

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.

— Backerupper
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.