Comment déterminer si un nombre est positif ou négatif ?

Question

Lors d'un entretien, on m'a demandé comment déterminer si un nombre est positif ou négatif. Les règles sont que nous ne devons pas utiliser les opérateurs relationnels tels que < y > des fonctions java intégrées (comme substring , indexOf , charAt y startsWith ), pas de regex, ni d'API.

J'ai fait quelques recherches à ce sujet et le code est donné ci-dessous, mais il ne fonctionne que pour le type entier. Mais ils m'ont demandé d'écrire un code générique qui fonctionne pour les types float , double y long .

 // This might not be better way!!

 S.O.P ((( number >> 31 ) & 1) == 1 ? "- ve number " : "+ve number );

Des idées de votre côté ?

Answer 1

Les cas entiers sont faciles. Le cas des doubles est plus délicat, jusqu'à ce que vous vous souveniez des infinis.

Note : Si vous considérez que les constantes doubles font "partie de l'api", vous pouvez les remplacer par des expressions débordantes comme 1E308 * 2 .

int sign(int i) {
    if (i == 0) return 0;
    if (i >> 31 != 0) return -1;
    return +1;
}
int sign(long i) {
    if (i == 0) return 0;
    if (i >> 63 != 0) return -1;
    return +1;
}
int sign(double f) {
    if (f != f) throw new IllegalArgumentException("NaN");
    if (f == 0) return 0;
    f *= Double.POSITIVE_INFINITY;
    if (f == Double.POSITIVE_INFINITY) return +1;
    if (f == Double.NEGATIVE_INFINITY) return -1;

    //this should never be reached, but I've been wrong before...
    throw new IllegalArgumentException("Unfathomed double");
}

Answer 2

Ce qui suit est une approche terrible qui vous ferait virer dans n'importe quel emploi...

Cela dépend de l'obtention d'une exception Stack Overflow [ou quel que soit le nom que Java lui donne]... Et cela ne fonctionnerait que pour les nombres positifs qui ne s'écartent pas de 0 comme un fou.

Les nombres négatifs ne posent pas de problème, car ils déborderaient en positif, ce qui entraînerait une exception de débordement de pile [qui renverrait false, ou "oui, c'est négatif"].

Boolean isPositive<T>(T a)
{
  if(a == 0) return true;
  else
  {
    try
    {
      return isPositive(a-1);
    }catch(StackOverflowException e)
    {
      return false; //It went way down there and eventually went kaboom
    }
  }
}

Answer 3

Cela ne fonctionne que pour tout sauf [0..2].

boolean isPositive = (n % (n - 1)) * n == n;

Vous pouvez trouver une meilleure solution comme celle-ci (fonctionne sauf pour [0..1])

boolean isPositive = ((n % (n - 0.5)) * n) / 0.5 == n;

Vous pouvez obtenir une meilleure précision en remplaçant la partie 0,5 par quelque chose comme 2^m (m entier) :

boolean isPositive = ((n % (n - 0.03125)) * n) / 0.03125 == n;

Answer 4

Vous pouvez faire quelque chose comme ça :

((long) (num * 1E308 * 1E308) >> 63) == 0 ? "+ve" : "-ve"

L'idée principale ici est d'effectuer un cast vers un long et de vérifier la valeur du bit le plus significatif. Comme un double/float compris entre -1 et 0 sera arrondi à zéro lorsqu'il est converti en un long, nous multiplions par de grands doubles afin qu'un float/double négatif soit inférieur à -1. Deux multiplications sont nécessaires en raison de l'existence de subnormaux (il n'a pas besoin d'être aussi grand).

Answer 5

// Returns 0 if positive, nonzero if negative
public long sign(long value) {
    return value & 0x8000000000000000L;
}

Appelez comme ça :

long val1 = ...;
double val2 = ...;
float val3 = ...;
int val4 = ...;

sign((long) valN);

Le transfert d'un double / float / integer vers un long devrait préserver le signe, mais pas la valeur réelle...