We have the first value of a certain sequence, we will name it ```initVal```.
We define  pattern list, ```patternL```, an array that has the differences between contiguous terms of the sequence.
``` E.g: patternL = [k1, k2, k3, k4]``` 

The terms of the sequence will be such values that:
```python
term1 = initVal
term2 - term1 = k1
term3 - term2 = k2
term4 - term3 = k3
term5 - term4 = k4
term6 - term5 = k1
term7 - term6 = k2
term8 - term7 = k3
term9 - term8 = k4
....  - ..... = ...
....  - ..... = ...
 ``` 
So the values of the differences between contiguous terms are cyclical and are  repeated as the differences values of the pattern list stablishes.

Let's see an example with numbers:
```python
initVal = 10
patternL = [2, 1, 3]
term1 = 10
term2 = 12
term3 = 13
term4 = 16
term5 = 18
term6 = 19
term7 = 22  # and so on...
```
We can easily obtain the next terms of the sequence following the values in the pattern list.
We see that the sixth term of the sequence, ```19```, has the sum of its digits ```10```.

Make a function ```sumDig_nthTerm()```, that receives three arguments in this order 

 ```sumDig_nthTerm(initVal, patternL, nthTerm(ordinal number of the term in the sequence)) ```

This function will output the sum of the digits of the n-th term of the sequence.

Let's see some cases for this function:
```python
sumDig_nthTerm(10, [2, 1, 3], 6) -----> 10 # because the sixth term is 19 sum of Dig = 1 + 9 = 10. The sequence up to the sixth-Term is: 10, 12, 13, 16, 18, 19

sumDig_nthTerm(10, [1, 2, 3], 15) ----> 10 # 37 is the 15-th term, and 3 + 7 = 10
```
Enjoy it and happy coding!!

Difficulty: EASY
Starter code: def sumDig_nthTerm(initVal, patternL, nthTerm):
	

Solutions:
from itertools import cycle

def sumDig_nthTerm(initVal, patternL, nthTerm):
	for (c, i) in enumerate(cycle(patternL), 2):
		initVal += i
		if c == nthTerm:
			return sum((int(v) for v in str(initVal)))


def sumDig_nthTerm(base, cycle, k):
	(loop, remaining) = divmod(k - 1, len(cycle))
	term = base + loop * sum(cycle) + sum(cycle[:remaining])
	return sum((int(d) for d in str(term)))


def sumDig_nthTerm(initVal, patternL, nthTerm):
	(q, r) = divmod(nthTerm - 1, len(patternL))
	x = initVal + q * sum(patternL) + sum(patternL[:r])
	return sum(map(int, str(x)))


from itertools import cycle as c, islice as isl
sumDig_nthTerm = lambda ini, p, n: sum(map(int, str(ini + sum(list(isl(c(p), n - 1))))))


sumDig_nthTerm = lambda st, p, n: sum(map(int, str(st + sum(p) * ((n - 1) // len(p)) + sum(p[:(n - 1) % len(p)]))))


def sumDig_nthTerm(initVal, patternL, nthTerm):
	n = initVal
	for i in range(nthTerm - 1):
		n += patternL[i % len(patternL)]
	return sum((int(d) for d in str(n)))