Cubo quadrado e perfeito perfeito

Question

Existe alguma função predefinida em C ++ para verificar se o número é quadrado de qualquer número e o mesmo para o cubo.

Answer 1

Não, mas é fácil escrever um:

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

Answer 2

sqrt(x), ou em geral, pow(x, 1./2) ou pow(x, 1./3)

Por exemplo:

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

Editar: ou em geral:

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

Answer 3

Experimente isso:

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

Answer 4

Não, não existem funções padrão C ou C ++ para verificar se um número inteiro é um quadrado perfeito ou um cubo perfeito.

Se você deseja que seja rápido e evite usar as rotinas float/duplo mencionadas na maioria das respostas, codifique uma pesquisa binária usando apenas números inteiros. Se você puder encontrar um n com n^2 <m <(n+1)^2, então M não é um quadrado perfeito. Se m é um quadrado perfeito, você encontrará um n com n^2 = m. O problema é discutido aqui

Answer 5

Para identificar quadrados, tentei esse algoritmo em Java. Com pouca diferença de sintaxe, você também pode fazê -lo em C ++. A lógica é que a diferença entre cada dois quadrados perfeitos consecutivos continuam aumentando em 2. Dif (1,4) = 3, diff (4,9) = 5, diff (9,16) = 7, diff (16,25 ) = 9 ..... continua. Podemos usar esse fenômeno para identificar os quadrados perfeitos. O código Java é,

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

Para tornar a identificação de quadrados mais rapidamente, podemos usar outro fenômeno, a soma recursiva de dígitos dos quadrados perfeitos é sempre 1,4,7 ou 9. Portanto, um código muito mais rápido pode ser ...

  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;


     }

  }

Answer 6

Para quadrado perfeito, você também pode fazer:

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

Para um cubo perfeito, você pode:

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

Espero que isto ajude.

Answer 7

Poderíamos usar o embutido truc função -

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

Answer 8

A resposta mais eficiente pode ser esta

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

Esse método funciona devido ao fato de que X é um INT e diminuirá a parte decimal para armazenar apenas a parte inteira. Se um número for um quadrado perfeito de um número inteiro, sua raiz quadrada será um número inteiro e, portanto, x e sqrt (x) serão iguais.