Der einfachste Weg zu überprüfen, ob zwei ganze Zahlen das gleiche Vorzeichen haben?

Ist der einfachste Weg, um zu überprüfen, ob zwei ganze zahlen haben gleiche Vorzeichen? Gibt es eine kurze bitweise trick, dies zu tun?

InformationsquelleAutor der Frage | 2008-09-15

44

Hier ist eine version, die funktioniert in C/C++, die sich nicht auf integer-Größen oder das overflow-problem (D. H. x*y>=0 nicht funktioniert)
```
bool SameSign(int x, int y)
{
    return (x >= 0) ^ (y < 0);
}
```
Natürlich können Sie geek out und template:
```
template <typename valueType>
bool SameSign(typename valueType x, typename valueType y)
{
    return (x >= 0) ^ (y < 0);
}
```
Hinweis: Da wir mittels exklusiv-oder -, wir wollen, dass die LHS und der RHS anders sein, wenn die Anzeichen sind die gleichen, damit die anderen check gegen null.

InformationsquelleAutor der Antwort Torlack
195

Was ist falsch mit
```
return ((x<0) == (y<0));  
```
?

InformationsquelleAutor der Antwort Rik
20
```
(a ^ b) >= 0
```
wird die Bewertung 1, falls das Zeichen gleich ist, sonst 0.

InformationsquelleAutor der Antwort
12

Ich würde vorsichtig sein, von jedem bitweise tricks, um zu bestimmen, die Zeichen der zahlen, dann machen Sie Annahmen darüber, wie diese zahlen intern dargestellt.

Fast 100% der Zeit, ganze zahlen gespeichert werden, wie zwei s Komplimentaber es ist keine gute Praxis, um Annahmen über Interna eines Systems, es sei denn, Sie verwenden den Datentyp, dass garantiert ein bestimmtes Speicherformat.

In zwei s Kompliment, Sie können einfach überprüfen Sie die Letzte (am weitesten Links stehende) bit in integer um festzustellen, ob es negativ ist, damit Sie vergleichen können, nur diese zwei bits. Dies würde bedeuten, dass würde 0 haben die gleiche Bedeutung wie eine positive Zahl, aber, das ist an der Verschiedenheit mit der sign-Funktion implementiert, die in den meisten Sprachen.

Persönlich, würde ich nur verwenden die Zeichen-Funktion der gewählten Sprache. Es ist unwahrscheinlich, dass es irgendwelche performance-Probleme mit einer Berechnung wie diese.

InformationsquelleAutor der Antwort SpoonMeiser
6

Vorausgesetzt, 32-bit-ints:
```
bool same = ((x ^ y) >> 31) != 1;
```
Etwas verständlicher:
```
bool same = !((x ^ y) >> 31);
```
InformationsquelleAutor der Antwort Patrick
5

Ich bin mir nicht wirklich sicher, ob ich als "bitweise trick" und "einfachste" gleichbedeutend. Ich sehe eine Menge von Antworten, vorausgesetzt, vorzeichenbehaftete 32-bit-Ganzzahlen (obwohl es würde dumm zu Fragen, unsigned); ich bin mir nicht sicher, Sie würden es anwenden, um floating-point-Werte.

Scheint es, wie die "einfachste" prüfen, wäre ein Vergleich wie sich die beiden Werte vergleichen zu 0, das ist ziemlich allgemein angenommen, die Typen verglichen werden kann:
```
bool compare(T left, T right)
{
    return (left < 0) == (right < 0);
}
```
Wenn die Schilder sind gegenständig, erhalten Sie falsch. Wenn die Zeichen identisch sind, erhalten Sie " true.

InformationsquelleAutor der Antwort OwenP
4

(integer1 * integer2) > 0

Weil wenn zwei ganze zahlen teilen, ein Zeichen, das Ergebnis der Multiplikation immer positiv.

Können Sie machen es auch >= 0, wenn Sie möchten, gönnen Sie 0 als das gleiche Zeichen, egal was.

InformationsquelleAutor der Antwort Benjamin Autin
4

Vorausgesetzt, zweier-Komplement-Arithmetik (http://en.wikipedia.org/wiki/Two_complement):
```
inline bool same_sign(int x, int y) {
    return (x^y) >= 0;
}
```
Dies kann so wenig wie zwei Anweisungen, und weniger als 1ns auf einem modernen Prozessor mit Optimierung.

Nicht vorausgesetzt, zweier-Komplement-Arithmetik:
```
inline bool same_sign(int x, int y) {
    return (x<0) == (y<0);
}
```
Diese können verlangen, ein oder zwei zusätzliche Anweisungen und ein wenig länger dauern.

Mit der Multiplikation ist eine schlechte Idee, denn es ist anfällig für einen Pufferüberlauf.

InformationsquelleAutor der Antwort user10315
2

wenn (x * y) > 0...

unter der Annahme nicht-null und so.

InformationsquelleAutor der Antwort Yes - that Jake.
2

Als technischer Hinweis, bit twiddly Lösungen sind viel effizienter als die Multiplikation, auch auf modernen Architekturen. Es ist nur etwa 3 Zyklen, dass Sie sparen, aber Sie wissen, was Sie sagen, über einen "Pfennig"...

InformationsquelleAutor der Antwort Daniel Spiewak
1

Nur aus der Spitze von meinem Kopf...
```
int mask = 1 << 31;
(a & mask) ^ (b & mask) < 0;
```
InformationsquelleAutor der Antwort Daniel Spiewak
1

vorausgesetzt 32 bit

if ( ((x^y) & 0x80000000) == 0)

... die Antwort, wenn(x*y>0) ist schlecht wegen überlaufs

InformationsquelleAutor der Antwort ugasoft

astfreie C version:

int sameSign(int a, int b) {
    return ~(a^b) & (1<<(sizeof(int)*8-1));
}

C++ template für integer-Typen:

template <typename T> T sameSign(T a, T b) {
    return ~(a^b) & (1<<(sizeof(T)*8-1));
}

InformationsquelleAutor der Antwort CAFxX

1

Für jede Größe der Ganzzahl, Zweierkomplement-Arithmetik:
```
#define SIGNBIT (~((unsigned int)-1 >> 1))
if ((x & SIGNBIT) == (y & SIGNBIT))
    //signs are the same
```
InformationsquelleAutor der Antwort Mark Ransom
0

wenn (a*b < 0) - Zeichen ist anders, anderes Zeichen ist die gleiche (oder a oder b ist null)

InformationsquelleAutor der Antwort
0

Denken wir zurück an meine Studienzeit in den meisten Darstellungen Maschine, nicht das am weitesten Links stehende bit einer integer eine 1, wenn die Zahl negativ ist, und 0, wenn es positiv ist?

Ich denke, das ist eher Rechner abhängig, obwohl.

InformationsquelleAutor der Antwort Dana
0

int same_sign = !( (x >> 31) ^ (y >> 31) );

wenn ( same_sign ) ...
sonst ...

InformationsquelleAutor der Antwort
0

Besser Weg mit std::signbit wie folgt:
```
std::signbit(firstNumber) == std::signbit(secondNumber);
```
Es unterstützt auch die anderen Grundtypen (doublefloatchar etc).

InformationsquelleAutor der Antwort ashiquzzaman33

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.