Looking at consecutive powers of `2`, starting with `2^1`:

`2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, ...`

Note that out of all the digits `0-9`, the last one ever to appear is `7`. It only shows up for the first time in the number `32768 (= 2^15)`.

So let us define LAST DIGIT TO APPEAR as the last digit to be written down when writing down all the powers of `n`, starting with `n^1`.


## Your task

You'll be given a positive integer ```1 =< n <= 10000```, and must return the last digit to appear, as an integer.

If for any reason there are digits which never appear in the sequence of powers, return `None`/`nil`.

Please note: The Last digit to appear can be in the same number as the penultimate one. For example for `n = 8`, the last digit to appear is `7`, although `3` appears slightly before it, in the same number:
`8, 64, 512, 4096, 32768, ...`

Difficulty: introductory

Starter code:

def LDTA(n):
	

Solutions:
digits = lambda x: set(str(x))

def LDTA(n):
    if digits(n) == digits(n*n):
        return None
    
    seen = []
    x = n
    
    while len(seen) < 10:
        for d in str(x):
            if d not in seen:
                seen.append(d)
        x *= n
        
    return int(seen[-1])

def LDTA(n):
    x,s = n,set(str(n))
    for _ in range(30):
        x *= n
        for d in str(x):
            s.add(d)
            if len(s)==10: return int(d)

import math
def LDTA(n):
    if math.log10(n) == int(math.log10(n)): return None
    d = {0:0,1:0,2:0,3:0,4:0,5:0,6:0,7:0,8:0,9:0}
    c = n
    while 1:
        for i in str(c):
            d[int(i)] = 1
            if sum(d.values()) == 10:
                return int(i)
        c *= n
    return -1

import math
def LDTA(n):
    if(n==1 or math.log10(n)%1 == 0):
        return None
    else:
        power = 1
        digits = [d for d in range(0,10)]
        while(digits):
            number = [int(x) for x in str(n**power)]
            for x in number:
                if(x in digits):
                    last_one = x
                    digits.remove(x)
            power+=1
        return last_one

def LDTA(n):
    digits = []
    num = 1
    pow = 1
    while num < n**pow and pow < 20:
        num *= n
        pow += 1
        if len(digits) == 10:
            return digits[-1]
        else:
            for d in str(num):
                if int(d) not in digits:
                    digits.append(int(d))
    return None

def LDTA(n):
    if set(str(n)) == set(str(n ** 2)):
        return
    res, i = [], 0
    while True:
        i += 1
        for digit in str(n ** i):
            if digit not in res:
                res.append(digit)
            if len(res) >= 10:
                return int(res[-1])


def LDTA(n):
    remaining = set(range(10))
    for i in range(1, 100):
        for s in str(n**i):
            t = int(s)
            remaining.discard(t)
            if not remaining:
                return t

def LDTA(n):
    if n in (1, 10, 100, 1000, 10000):
        return None
    digits = set("0123456789")
    k = 1
    while True:
        p = str(n**k)
        for digit in p:
            digits -= {digit}
            if len(digits) == 1:
                return int(digits.pop())
        k += 1

from itertools import islice

def iter_powers(n):
    x = n
    while True:
        yield from map(int, str(x))
        x *= n


def LDTA(n):
    appear = set(range(10))
    for x in islice(iter_powers(n), 1000):
        appear.discard(x)
        if len(appear) == 1:
            return appear.pop()

def is_enough(lst):
    return len(lst) >= 10

def LDTA(n):
    res = []
    for i in range(1, 20):
        c = str(n ** i)
        for digit in c:
            if digit not in res:
                res.append(digit)
            if is_enough(res): break
        if is_enough(res): break
    if is_enough(res):
        return int(res[-1])
    return