Técnica de optimización de código (Y lógico y O lógico)

AND lógico (&&)

Al usar && (AND lógico), debemos poner primero la condición cuya probabilidad de obtener falso es alta para que el compilador no necesite verificar la segunda condición si la primera es falsa.
 

#include <bits/stdc++.h>
using namespace std;
// Function to check whether n is odd
bool isOdd(int n) { return (n & 1); }
 
// Function to check whether n is prime
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    for (int i = 2; i <= sqrt(n); i++)
        if ((n % i) == 0)
            return false;
    return true;
}
 
int main()
{
    int cnt = 0, n = 10;
 
    // Implementation 1
    for (int i = 2; i <= n; i++) {
        if (isOdd(i) && isPrime(i))
            cnt++;
    }
 
    cnt = 0;
    n = 10;
 
    // Implementation 2
    for (int i = 2; i <= n; i++) {
        if (isPrime(i) && isOdd(i))
            cnt++;
    }
}

# Function to check whether n is odd
def isOdd(n):
    pass
 
# Function to check whether n is prime
def isPrime(n):
    pass
 
if __name__ == '__main__':
    cnt = 0; n = 10
 
    # Implementation 1
    for i in range(2,n) :
        if isOdd(i) and isPrime(i):
            cnt+=1
     
 
    cnt = 0
    n = 10
 
    # Implementation 2
    for i in range(2,n):
        if isPrime(i) and isOdd(i):
            cnt+=1
    

Considere la implementación anterior: 
 

En la implementación 1 , evitamos verificar los números pares, ya sea que sean primos o no, ya que la prueba de primalidad requiere más cálculos que verificar un número par/impar. 
La probabilidad de que un número se vuelva impar es mayor que la de que sea primo, por eso primero verificamos si el número es impar antes de verificar si es primo. 
 

Por otro lado , en la implementación 2 , estamos verificando si el número es primo o no antes de verificar si es impar, lo que hace que el cálculo sea innecesario, ya que todos los números pares que no sean 2 no son primos, pero la implementación aún los verifica como primos. 
 

O lógico (||)

Mientras usa || (OR lógico), debemos poner primero la condición cuya probabilidad de ser verdadera sea alta para que el compilador no necesite verificar la segunda condición si la primera condición es verdadera.
 

#include <iostream.h>
 
// Function to check whether n is odd
bool isEven(int n);
 
// Function to check whether n is prime
bool isPrime(int n);
 
int main()
{
    int cnt = 0, n = 10;
 
    // Implementation 1
    for (int i = 3; i <= n; i++) {
        if (isEven(i) || !isPrime(i))
            cnt++;
    }
}

# Function to check whether n is even
def isEven(n):
    pass
 
# Function to check whether n is prime
def isPrime(n):
    pass
 
if __name__ == '__main__':
    cnt = 0; n = 10
 
    # Implementation 1
    for i in range(3,n) :
        if isOdd(i) or not isPrime(i):
            cnt+=1

Como se describió anteriormente, la probabilidad de que un número sea par es mayor que la de que no sea primo. El orden actual de ejecución de las sentencias no permite comprobar si los números pares mayores de 2 no son primos (ya que todos son no primos). 
 

Nota: Para entradas más grandes, el orden de ejecución de las sentencias puede afectar el tiempo de ejecución general del programa.