Programma C per confrontare gli interi senza utilizzare operatori logici?

Question

Qualcuno può dirmi come scrivere un programma C per confrontare i numeri (compresi i numeri negativi) senza utilizzare operatori logici?

Answer 1

Ecco un programma che confronta i due numeri senza utilizzare gli operatori di relazione (funziona anche con numeri negativi). controlla.

/------ programma C -------/

void main() 
{ 
    int a,b,c,temp; 
    printf("enter a and b:"); 
    scanf("%d%d",&a,&b); 
    c=a-b; 
    temp=c+abs(c);  // to check if the difference is negative or not 
    if(temp==0) 
    printf("a is smaller than b"); 
    else 
    printf("a is bigger than b"); 
    getch(); 
    } 

EDIT: codice rivisto di Maddy (dal suo commento qui sotto) segue.

void main() { 
    int a,b,c,d,temp; 
    printf("enter a and b:"); 
    scanf("%d%d",&a,&b); 
    c=a-b; 
    d=abs(c); 
    temp=c+d; 
    if (c==0) printf("a is equal to b"); 
    else if(temp==0) printf("a is smaller than b"); 
    else printf("a is bigger than b"); 
    printf("%d",d); getch(); 
} 

Penso che ora il codice funziona bene per tutti gli ingressi ...

Answer 2

Sì, puoi sottrarli e osservare la differenza.

Lo so, questo porta alla domanda successiva: come puoi sapere se la differenza è < 0, = 0 o> 0? Bene, puoi occuparti di < 0 controllando se il bit di segno è impostato.

Answer 3

Supponiamo di avere int x e int y. Sia int z = x-y, e poi ripetutamente (31 o 63 volte a seconda delle preferenze) prendi z | = z < < 1 e z | = z >> 1. Se la differenza è zero, z = 0 e se la differenza è diversa da zero, z = -1. Aggiungi da uno a z e usalo per indicizzare in una matrice di puntatori di funzione che contengono le istruzioni che vuoi seguire in ciascun caso.

È possibile eseguire questa operazione in modo più efficiente se è possibile utilizzare l'assemblaggio, ma poiché questo non sembra un problema pratico, non penso che tali soluzioni valgano la pena di esplorarle troppo profondamente. Se volevi una soluzione pratica, dovresti semplicemente utilizzare gli operatori logici :)

Ora, la dichiarazione del problema è molto discutibile in quanto l'aritmetica del computer viene definita utilizzando "operatori logici" ma se si assume ingenuamente (come probabilmente ti vogliono a) che quello che scrivi è quello che usi, la soluzione di cui sopra dovrebbe essere sufficiente.

EDIT: È NON necessario utilizzare if/else. Se il segno del confronto è importante, portare il segno nella posizione 2s e usarlo per indicizzare in una matrice di puntatore a funzione.

Answer 4

Non abbiamo intenzione di fare i compiti, ma lasciatemi aggiungere alcuni suggerimenti su come procedere. Partiamo dal presupposto che stiamo andando a confrontare a e b.

1. Come Carl states, si consiglia di guardare la differenza d = a - b.
   • Osservazione: d può essere negativo, zero o positivo.
   • Domanda: quale valore di d corrisponde alla quale (dis) uguaglianza di un e b?
2. Una volta calcolato d e sa come interpretarlo, è necessario trovare il modo per controllarli senza l'utilizzo di operatori logici.
   • Osservazione: i candidati evidenti sono bitwise operators.
   • Domanda: ma in che modo i computer (di solito) memorizzano numeri interi?
   • Suggerimento: dare un'occhiata a two's complement.
   • Domanda: come si può distinguere tra un numero negativo e un numero non negativo?
3. Ora avete tutte le informazioni necessarie per rispondere alla domanda.
   • Suggerimento: sei, naturalmente, ha permesso di utilizzare if e else dichiarazioni.
   • Suggerimento: si consiglia di utilizzare INT_MIN da limits.h.

Edit: questa risposta, e la maggior parte delle altre risposte qui per scontato che il PO non è consentito utilizzare logical e relational (confronto) operatori. Tuttavia, l'OP menziona esplicitamente che gli operatori logici non sono consentiti. Penso che la ragione principale di questo equivoco sia il fatto che il problema è banale da risolvere usando operatori di confronto.

Answer 5

È possibile utilizzare gli operatori relazionali (<,>, < =,> =) e/o gli operatori di uguaglianza (== ,! =).

Answer 6

Ecco un programma che confronta i due numeri senza utilizzare operatori di relazione (funziona anche con numeri negativi).

void main() 
{ 
    int a,b,c,d,temp; 
    printf("enter a and b:"); 
    scanf("%d%d",&a,&b); 
    c=a-b; 
    d=abs(c); 
    temp=c+d; 
    if(c==0) 
     printf("a is equal to b"); 
    else if(temp==0) 
     printf("a is smaller than b"); 
    else 
     printf("a is bigger than b"); 
    printf("%d",d); 
    getch(); 
} 

Penso che ora il codice funziona bene per tutti gli ingressi ...

Answer 7

Tenete a mente che operatore logico sono molto più veloce di operatori aritmetici.

Come risposta per voi ...

if(x-y){ elements are different}else{ they are equals} 

Answer 8

Questo è il gemello cattivo di Carl, qui per dirvi che sei smidollati tutto gracile!

Ecco una soluzione che non solo senza operatori logici, ma anche senza operatori relazionali (compresi ==) e senza if. Solo aritmetica e indicizzazione, piccola!

#include "stdio.h" 
#include "limits.h" 
int sign(int number) { 
    return (unsigned) number/(unsigned) INT_MIN; 
} 
int main(int argc, char *argv[]) { 
    int a = atoi(argv[1]); 
    int b = atoi(argv[2]); 
    int dif = a - b; 
    int sb1 = sign(dif); 
    int sb2 = sign(dif - 1) - sb1; 
    int ptr = 2 * sb2 + sb1; 
    char *messages[3] = { 
    "%d is greater than %d", 
    "%d is less than %d", 
    "%d is equal to %d" }; 
    printf(messages[ptr], a, b); 
} 

Alcuni risultati dei test:

$ ./compare 42 69 
42 is less than 69 

$ ./compare 69 42 
69 is greater than 42 

$ ./compare 42 -15 
42 is greater than -15 

$ ./compare 999 999 
999 is equal to 999 

$ ./compare -9 -10 
-9 is greater than -10 

La domanda iniziale, d'altra parte, è molto più facile. Gli operatori logici sono solo !, &, &&, |, || e !.Penso che un paio di if s annidati lo farebbero facilmente.

Answer 9

Prova questo:

if(a-b) 
    printf("They are not equal"); 
else 
    printf("They are equal"); 

Answer 10

int a = 2; 
int b = 1; 

int c = a - b; 

switch(c) 
{ 
    case 0: 
     System.out.println("equal"); 
    break; 

    default: 
     int min = Math.min(a, b); 

     switch(a - min) 
     { 
      case 0: 
       System.out.println("a lesser than b"); 
      break; 
      default: 
       System.out.println("a greater than b"); 
     } 
} 

Con la prima sottrazione viene controllato se i due numeri sono uguali, perché a-b=0 solo se a e b sono gli stessi. Quindi siamo nel caso predefinito del primo interruttore solo se a e b sono diversi.
ora in corso il min da a e b (qui è il trucco, c'è un implicito se con gli operatori logici all'interno della funzione Math.min) siamo in grado di sottrarre a con questo min. Se il risultato è 0 significa che a è minore di b.
L'ultimo caso è il rimanente, quindi a maggiore di b. Con le lingue che accettano numeri interi nella clausola if (0 ->false, altro->true) è possibile utilizzare if anziché switch (non per java).

Answer 11

Buono. a-b è ovvio, ma poi verificare se a<b o a>b mi ha fermato per un po ', se non si usano anche le maschere di bit ... È bello tornare a cose del genere una volta ia mentre, fa sì che l'esperienza impedisca di cercare alternative soluzioni. ;) Ecco quello che mi si avvicinò con:

// -1 means a<b; 0 means a=b; 1 means a>b 
char cmp(double a, double b) 
{ 
    // (diff-1)/diff gives 1 or 2 if diff < 0 (e.g. -2/-1) = then a<b; 0 otherwise = a>b : 
    return (a = a - b) 
     ? (int)((a - 1)/a) ? -1 : 1 
     : 0; 
} 

Answer 12

Se non ti dispiace un inefficiente ciclo while i seguenti lavori ragionevolmente bene ed è semplice da leggere. XOR gli input e quindi sposta la risposta finché il risultato non è 1 o 0 (non una corrispondenza o una corrispondenza).

#include <stdio.h> 

int main(int argc, char *argv[]) 
{ 
    int first_number = atoi(argv[1]); 
    int second_number = atoi(argv[2]); 

    unsigned int not_equal = (first_number^second_number); 

    while (not_equal & ~0x01) 
     not_equal >>= 1; 

    char *response[2] = { "Numbers Match!\n", 
          "Numbers don't match...\n"}; 

    printf(response[not_equal]); 

    return 0; 
}