Pour trouver le plus proche de carré parfait si le nombre entré n'est pas un carré parfait?

#include <iostream>
#include <limits>
#include <cmath>

using namespace std;

int main()
{
    int number;
    cout << "Enter the number whose sqare root needs to be calculated";
    cin >> number;
    cout << "Square root of " << number << " is " << (int)sqrt((float)number)  << " OR " << sqrt((float)number) << endl;
    if( (int)sqrt((float)number) == sqrt((float)number) )
    cout << "The number is a perfect sqaure";
    else
    cout << "The number is not a perfect square";
    //To find the nearest perfect square if the number entered
   //is not a perfect square?

    return 0;
}

J'espère que ce que j'ai fait pour vérifier l'carrés parfaits est OK, mais ensuite, je veux vous
trouver le nombre le plus proche carré parfait si le nombre entré n'est pas un carré parfait
Toutes Les Idées

OriginalL'auteur munish | 2011-05-19

c++

11

En fait, ici, c'est la meilleure réponse:
```
int number = 13;
int iRoot = static_cast<int>(sqrt(static_cast<float>(number)) + .5f);
```
Vous n'avez pas besoin de vérifier entre le plafond ou le plancher de ce qui est plus important, de faire un simple tour fait le tour.

sqrt(13) est de 3,6 et lorsque vous ajoutez .5 jette à 4. sqrt(12) est de 3,46 et lorsque vous ajoutez .5 jette à 3. (nous essayons de ronde, qui est pourquoi nous ajoutons l'.5). Comme vous pouvez le voir, lorsque le nombre est plus proche à la plus élevée de la racine, ça va vous donner une décimale de plus que le 5; lorsque le nombre est plus proche d'une baisse de la valeur de la racine, la virgule est inférieur à 5, tout simplement!

+1 pour minimiser le nombre de comparaisons - bien que veredesmarald la solution est probablement plus rapide à comprendre pour ceux qui ont à maintenir le code plus tard!
Devriez probablement utiliser double plutôt que float, cependant, il est beaucoup plus susceptibles d'être capable de représenter avec précision toutes les valeurs de int.
cela semble être une belle affaire...loking en elle
La racine carrée peut avoir de partie fractionnaire > .5 et être encore plus proche de le petit carré parfait, par exemple pour 380.3 (sqrt = 19.501...) votre méthode renvoie 400 au lieu de 361. I pense votre méthode fonctionne pour tout entier entrées.
Oui, semble être un problème avec la prise de la racine carrée d'un nombre décimal. En prenant la racine carrée de .25 est le 5, et 5 est .7. Donc, il ya certaines choses que vous feriez différemment avec une virgule, mais on pouvait toujours faire les mêmes trucs, je pense. Je n'ai pas eu l'occasion de tester ce tout à fait encore, mais je pense que vous pourriez être en mesure de s'en tirer avec cela: nombre à virgule = 380.499; int iRoot = static_cast<int>(sqrt(static_cast<float>(static_cast<int>(nombre + .5f))) + .5f); je suis assez sûr qu'il y a une meilleure manière de le faire, mais j'ai un examen à s'inquiéter pour l'instant. Donc, laissez-moi savoir ce que vous en pensez!

OriginalL'auteur leetNightshade
5

Commencez par trouver le plancher et le plafond de la racine:
```
float root = sqrt((float)number);
int floor = (int)root;
int ceil = floor + 1
```
Alors il suffit de cocher ce qui est plus proche de ceil * ceil et floor * floor.

En fait, il y a un moyen plus rapide, découvrez ma réponse!

OriginalL'auteur verdesmarald
3

Carrés entiers à côté de la racine.

OriginalL'auteur Oswald
2

Laisser r être int(sqrt(double(number))+0.5). Ensuite, vous devez vérifier qui de (r-1)*(r-1), r*r et (r+1)*(r+1) est le plus proche de number. C'est tout.

pourquoi pensez-vous d'ajouter 0,5
C'est une façon d'arrondir à l'entier le plus proche, mais vous ne voulez pas vraiment à le faire dans ce cas car elle vous oblige à tester trois numéros au lieu de deux.
Cette réponse était proche de la bonne réponse, mais vous n'avez pas besoin de faire toutes les vérifications, le solution originale pour r ont travaillé en ajoutant .5 (voir ma réponse, qui est fondamentalement la même chose, avec juste un exemple).

OriginalL'auteur NPE
1

vous devez trouver les deux une puissance de deux: (int)sqrt((float)number) et ((int)sqrt((float)number)+1), (dénoter par d1,d2) et de trouver min{|number-d1|,|number-d2|}.

également, pour améliorer les performances, je l'aurais mis en cache le flotteur sqrt((float)number) comme une variable et de l'utiliser (au lieu de calculer à nouveau sqrt() )

OriginalL'auteur amit

Utiliser le même vérifier pour voir si un nombre est un carré parfait:

if( (int)sqrt((float)number) == sqrt((float)number) )

Et de l'appliquer successivement les entiers ci-dessus et ci-dessous le nombre spécifié par l'utilisateur.

int delta=1;
int perfectSquare = 0;
bool perfectSquareFound = false;
while(!perfectSquareFound)
{
   int above = number+delta;
   int below = number-delta;
   float aboveSquareRoot = sqrt((float)above);
   float belowSquareRoot = sqrt((float)below);
   if( (int)aboveSquareRoot == aboveSquareRoot )
   {
      perfectSquareFound = true;
      perfectSquare = above;
   }
   else if( (int)belowSquareRoot == belowSquareRoot )
   {
      perfectSquareFound = true;
      perfectSquare = below;
   }
}

C'est une horrible méthode inefficace. Vous avez tourné deux multiplications et une max potentiellement des milliers d'itérations!
Je suis complètement d'accord! C'est effectivement une méthode inefficace.

OriginalL'auteur phuibers

-1

Devrait être comme (pseudo code),

int sqrtValue = (int)sqrt((float)number);  //store in a temporary value
int lowerPerfectSquare = pow(sqrtValue, 2);
int higerPerfectSquare = pow(sqrtValue + 1, 2);
int nearPerfectSquare = (higerPerfectSquare - number) < (number - lowerPerfectSquare)?
                        sqrtValue + 1 : sqrtValue;

Pourquoi avez-vous calculer sqrt deux fois?
Ce calcule le plus grand carré parfait de moins de nombre, pas le plus proche.

OriginalL'auteur iammilind

Vous devez vous connecter pour publier un commentaire.