Último dígito en una potencia de 2

Dado un número n, necesitamos encontrar el último dígito de 2 ⁿ
 

Entrada: n = 4 
Salida: 6 
El último dígito en 2^4 = 16 es 6
Entrada: n = 11 
Salida: 8 
El último dígito en 2^11 = 2048 es 8 
 

Una solución ingenua es primero calcular potencia = pow(2, n), luego encontrar el último dígito en potencia usando potencia % 10. Esta solución es ineficiente y también tiene un problema de aritmética de enteros para n ligeramente grande.
Una Solución Eficiente se basa en que los últimos dígitos se repiten en ciclos de 4 si dejamos 2^0 que es 1. Las potencias de 2 (a partir de 2^1) son 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048,… 
Podemos notar que los últimos dígitos son 2, 4, 8, 6, 2, 4, 8, 6, 2, 4, 8,…
1) Calculamos rem = n % 4. Tenga en cuenta que el último rem tendrá un valor de 0 a 3. 
2) Devolvemos el último dígito de acuerdo con el valor del resto. 
 

Remainder   Last Digit
  1            2
  2            4
  3            8
  0            6

Ilustración: Sea n = 11, rem = n % 4 = 3. El último dígito de 2^3 es 8, que es el mismo que el último dígito de 2^11.
 

// C++ program to find last digit in a power of 2.
#include <bits/stdc++.h>
using namespace std;
 
int lastDigit2PowerN(int n)
{
 
    // Corner case
    if (n == 0)
        return 1;
 
    // Find the shift in current cycle
    // and return value accordingly
    else if (n % 4 == 1)
        return 2;
    else if (n % 4 == 2)
        return 4;
    else if (n % 4 == 3)
        return 8;
    else
        return 6; // When n % 4 == 0
}
 
// Driver code
int main()
{
    for (int n = 0; n < 20; n++)
        cout << lastDigit2PowerN(n) << " ";
    return 0;
}

// Java program to find last
// digit in a power of 2.
import java.io.*;
import java.util.*;
 
class GFG{
     
static int lastDigit2PowerN(int n)
{
     
    // Corner case
    if (n == 0)
        return 1;
 
    // Find the shift in current cycle
    // and return value accordingly
    else if (n % 4 == 1)
        return 2;
    else if (n % 4 == 2)
        return 4;
    else if (n % 4 == 3)
        return 8;
    else
        return 6; // When n % 4 == 0
}
 
// Driver code
public static void main(String[] args)
{
    for (int n = 0; n < 20; n++)
    System.out.print(lastDigit2PowerN(n) + " ");
}
}
 
// This code is contributed by coder001

# Python3 program to find last
# digit in a power of 2.
def lastDigit2PowerN(n):
     
    # Corner case
    if n == 0:
        return 1
 
    # Find the shift in current cycle
    # and return value accordingly
    elif n % 4 == 1:
        return 2
    elif n % 4 == 2:
        return 4
    elif n % 4 == 3:
        return 8
    else:
        return 6 # When n % 4 == 0
 
# Driver code
for n in range(20):
    print(lastDigit2PowerN(n), end = " ")
 
# This code is contributed by divyeshrabadiya07   

// C# program to find last
// digit in a power of 2.
using System;
class GFG{
     
static int lastDigit2PowerN(int n)
{
     
    // Corner case
    if (n == 0)
        return 1;
 
    // Find the shift in current cycle
    // and return value accordingly
    else if (n % 4 == 1)
        return 2;
    else if (n % 4 == 2)
        return 4;
    else if (n % 4 == 3)
        return 8;
    else
        return 6; // When n % 4 == 0
}
 
// Driver code
public static void Main(string[] args)
{
    for (int n = 0; n < 20; n++)
    {
        Console.Write(lastDigit2PowerN(n) + " ");
    }
}
}
 
// This code is contributed by rutvik_56

<script>
 
      // JavaScript program to find
      // last digit in a power of 2.
 
      function lastDigit2PowerN(n)
      {
        // Corner case
        if (n == 0)
        return 1;
         
        // Find the shift in current cycle
        // and return value accordingly
        else if (n % 4 == 1)
        return 2;
        else if (n % 4 == 2)
        return 4;
        else if (n % 4 == 3)
        return 8;
        else
        return 6; // When n % 4 == 0
      }
 
      // Driver code
      for (var n = 0; n < 20; n++)
      document.write(lastDigit2PowerN(n) + " ");
       
    </script>

1 2 4 8 6 2 4 8 6 2 4 8 6 2 4 8 6 2 4 8

Complejidad de tiempo: O(1) 
Espacio auxiliar: O(1)
¿Podemos generalizarlo para cualquier número de entrada? Consulte Encontrar el último dígito de a^b para números grandes