Parfait carré et cube parfait

Est-il un prédéfini fonction en c++ afin de vérifier si le nombre est le carré d'un nombre et de même pour le cube..

OriginalL'auteur d3vdpro | 2009-10-11

  1. 13

    Pas, mais il est facile d'en écrire un:

    bool is_perfect_square(int n) {
    if (n < 0)
        return false;
    int root(round(sqrt(n)));
    return n == root * root;
}

bool is_perfect_cube(int n) {
    int root(round(cbrt(n)));
    return n == root * root * root;
}
    Où voyez-vous une possibilité de division par zéro ? sqrt(0) et cbrt(0) sont définis.
    Cela ne fonctionne pas toujours, en raison de virgule flottante erreur: si sqrt() ou cbrt() arrive à retourner epsilon moins de la racine, la distribution d'un nombre entier de les tronquer, et la vérification échoue. Pour être complètement à l'épreuve des balles contre cela, vous devez également vérifier si n == (root + 1) * (root + 1) pour la racine carrée cas ou si n == (root + 1) * (root + 1) * (root + 1) pour la racine cubique de cas.
    Oh mon dieu, il me fait mal à la tête. J'ai continué à regarder pour la "racine" de la fonction jusqu'à ce que j'ai réalisé que vous étiez juste de l'initialisation d'un entier... je n'aime pas votre style de codage.
    Vous pouvez le détester tout ce que vous voulez, mais c'est le "plus standard" initialisation de style en C++, je pense que c'est appelé "constructeur de syntaxe" ou quelque chose comme ça. c'est à dire, si vous êtes à la construction d'un objet qui, par exemple, prend plus d'un paramètre dans le constructeur, vous auriez à utiliser la syntaxe de toute façon. Je n'aime pas à faire une exception pour les types numériques, donc j'utilise le constructeur de la syntaxe pour eux aussi.
    Oh mon dieu, je viens de me remettre à cette question et a essayé de laisser le même commentaire, puis remarqué que quelqu'un d'autre l'a déjà fait, puis essayé de upvote, mais ne pouvait pas trouver la flèche vers le haut, puis regarda l'utilisateur, et réalisa que c'était moi. Ne serait-il pas plus rapide de vérifier abs(root-round(root)) <= epsilon, plutôt que de multiplier?

    OriginalL'auteur Chris Jester-Young

  2. 6

    sqrt(x), ou en général, pow(x, 1./2) ou pow(x, 1./3)

    Par exemple:

    int n = 9;
int a = (int) sqrt((double) n);
if(a * a == n || (a+1) * (a+1) == n)  //in case of an off-by-one float error
    cout << "It's a square!\n";

    Edit: ou en général:

    bool is_nth_power(int a, int n) {
  if(n <= 0)
    return false;
  if(a < 0 && n % 2 == 0)
    return false;
  a = abs(a);

  int b = pow(a, 1. / n);
  return pow((double) b, n) == a || pow((double) (b+1), n) == a;
}
    Le problème avec l'aide de pow(x, 1./3) est que 1/3 n'ont pas une représentation exacte en virgule flottante, de sorte que vous n'êtes pas "vraiment" obtenir la racine cubique. Le C99 à partir de a cbrt, qui devrait faire un meilleur travail de la racine cubique.
    Je suppose que. Mais pow généralise plus facile, et il est assez facile à corriger pour virgule flottante erreurs.

    OriginalL'auteur Jesse Beder

  3. 1

    Essayez ceci:

    #include<math.h>
int isperfect(long n)
{
    double xp=sqrt((double)n);
    if(n==(xp*xp))
        return 1;
    else
        return 0;
}

    OriginalL'auteur nikoo28

  4. 1

    Non, il n'existe pas de standard de c ou de c++ les fonctions de vérifier si un entier est un carré parfait ou un cube parfait.

    Si vous voulez qu'il soit rapide et évitez d'utiliser le float/double routines mentionné dans la plupart des réponses, alors le code binaire de recherche utilisant que des nombres entiers. Si vous pouvez trouver un n avec n^2 < m < (n+1)^2, alors m n'est pas un carré parfait. Si m est un carré parfait, alors vous trouverez un n avec n^2=m. Le problème est discuté ici

    OriginalL'auteur Douglas B. Staple

  5. 0

    Pour l'identification des carrés, j'ai essayé cet algorithme en java. Avec peu de différence de syntaxe, vous pouvez le faire en c++.
    La logique est la différence entre chaque consécutive de deux carrés parfaits va croissant par 2. Diff(1,4)=3 , Diff(4,9)=5 , Diff(9,16)= 7 , Diff(16,25)= 9..... va sur.
    Nous pouvons utiliser ce phénomène pour identifier les carrés parfaits.
    Le code Java est,

        boolean isSquare(int num){
         int  initdiff = 3;
         int squarenum = 1;
         boolean flag = false;
         boolean square = false;
         while(flag != true){

                if(squarenum == num){

                    flag = true;
                    square = true;

                }else{

                    square = false;
                 }
                if(squarenum > num){

                    flag = true;
                }
            squarenum = squarenum + initdiff;
            initdiff = initdiff + 2;
   }
              return square;
 }

    Pour faire de l'identification des carrés plus rapide, nous pouvons utiliser un autre phénomène, le récursive somme des chiffres de carrés parfaits est toujours 1,4,7 ou 9.
    Donc beaucoup plus rapide code peut être...

      int recursiveSum(int num){
     int sum = 0;   
     while(num != 0){
     sum = sum + num%10;
     num = num/10;         
     }
     if(sum/10 != 0){         
        return recursiveSum(sum);     
     }
     else{
         return sum;
     }

 }
  boolean isSquare(int num){
         int  initdiff = 3;
         int squarenum = 1;
         boolean flag = false;
         boolean square = false;
         while(flag != true){

                if(squarenum == num){

                    flag = true;
                    square = true;

                }else{

                    square = false;
                 }
                if(squarenum > num){

                    flag = true;
                }
            squarenum = squarenum + initdiff;
            initdiff = initdiff + 2;
   }
              return square;
 }  

   boolean isCompleteSquare(int a){
    //System.out.println(recursiveSum(a));
     if(recursiveSum(a)==1 || recursiveSum(a)==4 || recursiveSum(a)==7 || recursiveSum(a)==9){

         if(isSquare(a)){

             return true;

         }else{
             return false;
         }


     }else{

         return false;


     }

  }

    OriginalL'auteur Deepeshkumar

  6. 0

    Pour carré parfait, vous pouvez aussi le faire:

    if(sqrt(n)==floor(sqrt(n)))
    return true;
else
    return false;

    Pour cube parfait, vous pouvez:

    if(cbrt(n)==floor(cbrt(n)))
    return true;
else
    return false;

    Espère que cette aide.

    SI c'était "sur le retour", pourquoi ne pas simplement return sqrt(n)==floor(sqrt(n))? (et pourquoi préférer floor à round?) Ensuite, il y a int r = round(cbrt(n)); return n == r*r*r - dont aucun n'est predefined, laissant ce n'est pas à notre 2016 connaissances: Chris réponse.

    OriginalL'auteur Prashant Shubham

  7. 0

    Nous pourrions utiliser la builtin truc fonction -

    #include <math.h>

//For perfect square
bool is_perfect_sq(double n) {
    double r = sqrt(n);
    return !(r - trunc(r));
}

//For perfect cube
bool is_perfect_cube(double n) {
    double r = cbrt(n);
    return !(r - trunc(r));
}

    OriginalL'auteur Gautham

  8. 0

    La plus efficace de la réponse pourrait être cette

        int x=sqrt(num)
    if(sqrt(num)>x){
    Then its not a square root}
    else{it is a perfect square}

    Cette méthode fonctionne parce que le fait que x est un int et il va descendre la partie décimale de stocker uniquement la partie entière. Si un nombre est un carré d'un nombre entier, sa racine carrée sera un entier et donc x et sqrt(x) sera égal.

    OriginalL'auteur Saurabh Kumar