using System;

using System.Linq;

​

namespace Solution

{

    public class Calculator

    {

        private static int[] patternLenghts = {1, // 0

             1, // 1

             4, // 2

             4, // 3

             2, // 4

             1, // 5

             1, // 6

             4, // 7

             4, // 8

             2, // 9

        };  

        private static int modWithoutZero(int a, int b)

        {

            return ((a - 1) % b) + 1;

        }

​

        private static int getLastDigitWithinBase(int[] list, int preservedBase)

        {

            if (list.Length == 1)

            {

                return modWithoutZero(list[0], preservedBase);

            }

​

            int currentRoot = list[0];

            int currentPatternLength = Calculator.patternLenghts[currentRoot];

            // LastDigits should preserve our final answer, even though they aren't the entire result.  This is done by taking advantage of the fact that there are repeating patterns in the last digits.

            // This should be enough for the recursion above to get the correct last 'digits' in whatever base it needs.

            int lastDigits = Calculator.getLastDigitWithinBase(list.Skip(1).ToArray<int>(), currentPatternLength);

            // Actual exponents, where we are at least preserving the last digits that are needed.

            return modWithoutZero(Convert.ToInt32(Math.Pow(currentRoot, lastDigits)), preservedBase);

        }

​

        public static int LastDigit(int[] array)

        {

            return Calculator.getLastDigitWithinBase(array, 10);

        }

​

        public static void Main()

        {

            Console.WriteLine(Calculator.LastDigit(new int[]{7, 0, 3}));

        }

    }

}/*

    import copy

​

    # Be careful with this, of course.  Just to check against small chunks

    def bruteForce(list):

​

        copyList = copy.deepcopy(list)

​

        n = copyList.pop()

        while(copyList):

            n = copyList.pop() ** n

        return n

​

    # This is a reference to the length of the pattern of last digits for (n ^ i).

    # For example, the last digits for 7 ^ i are 7, 9, 3, 1, 7, 9, 3, 1, 7, etc...

    patternLengths = {

        0: 1,

        1: 1,

        2: 4,

        3: 4,

        4: 2,

        5: 1,

        6: 1,

        7: 4,

        8: 4,

        9: 2,

    }

​

    def modWithoutZero(a, b):

      return ((a - 1) % b) + 1

​

    ## What we want to know is what the last digit of the result is based on a given root

    ## and what "base" we are expected to preserve.

    def getLastDigitWithinBase(list, base):

        if(len(list) == 1):

            return modWithoutZero(list[0], base)

        currentRoot = list[0]

        currentPatternLength = patternLengths[currentRoot]

​

        # LastDigits should preserve our final answer, even though they aren't the entire result.  This is done by taking advantage of the fact that there are repeating patterns in the last digits.

        # This should be enough for the recursion above to get the correct last 'digits' in whatever base it needs.

        lastDigits = getLastDigitWithinBase(list[1:], currentPatternLength)

​

        # Actual exponents, where we are at least preserving the last digits that are needed.

        return modWithoutZero(currentRoot ** lastDigits, base)

​

    testList = [3, 3, 2]

    print("Brute force answer: {}".format(bruteForce(testList) % 10))

    print("Fancy Shmancy answer: {}".format(getLastDigitWithinBase(testList, 10)))

​

    # Advantages:  Linear time and constant space outside of the stack.

    # Disadvantage: Prone to stack overflow.

    # It also doesn't seem to handle fractional exponents well, check if that could be in scope.

    */

​