# Introduction 

Digital Cypher assigns to each letter of the alphabet unique number. For example:

```
 a  b  c  d  e  f  g  h  i  j  k  l  m
 1  2  3  4  5  6  7  8  9 10 11 12 13
 n  o  p  q  r  s  t  u  v  w  x  y  z
14 15 16 17 18 19 20 21 22 23 24 25 26
```

Instead of letters in encrypted word we write the corresponding number, eg. The word scout:

```
 s  c  o  u  t
19  3 15 21 20
```
Then we add to each obtained digit consecutive digits from the key. For example. In case of key equal to `1939` :

```
   s  c  o  u  t
  19  3 15 21 20
 + 1  9  3  9  1
 ---------------
  20 12 18 30 21
  
   m  a  s  t  e  r  p  i  e  c  e
  13  1 19 20  5 18 16  9  5  3  5
+  1  9  3  9  1  9  3  9  1  9  3
  --------------------------------
  14 10 22 29  6 27 19 18  6  12 8
```

# Task

Write a function that accepts `str` string and `key` number and returns an array of integers representing encoded `str`.

# Input / Output

The `str` input string consists of lowercase characters only.
The `key` input number is a positive integer.

# Example

```
Encode("scout",1939);  ==>  [ 20, 12, 18, 30, 21]
Encode("masterpiece",1939);  ==>  [ 14, 10, 22, 29, 6, 27, 19, 18, 6, 12, 8]
```

# Digital cypher series
- [Digital cypher vol 1](https://www.codewars.com/kata/592e830e043b99888600002d)
- [Digital cypher vol 2](https://www.codewars.com/kata/592edfda5be407b9640000b2)
- [Digital cypher vol 3 - missing key](https://www.codewars.com/kata/5930d8a4b8c2d9e11500002a)

Difficulty: introductory

Starter code:

def encode(message, key):
	

Solutions:
from itertools import cycle

def encode(message, key):
    return [ord(a) - 96 + int(b) for a,b in zip(message,cycle(str(key)))]

def encode(message, key):
    # initialize variables
    output = []
    i = 0
    
    # convert key to a list of integers
    key = [int(d) for d in str(key)]
    
    # encode characters in 'message'
    for char in message:
        n = ord(char) + key[i]
        output.append(n-96)
        i = (i + 1) % len(key)
    
    # return the results
    return output


def encode(message, key):
    return [ ord(char) - 96 + int(str(key)[i % len(str(key))]) for i, char in enumerate(message) ]

import itertools
import string

def encode(message, key):
    return [string.ascii_lowercase.index(c) + k + 1 for c, k in zip(message, itertools.cycle(int(c) for c in str(key)))]

from itertools import cycle


def encode(message, key):
    return [ord(ch) - 96 + int(code) for
            ch, code in zip(message, cycle(str(key)))]

encode=lambda s,n:[ord(c)+int(d)-96for c,d in zip(s,str(n)*len(s))]

from itertools import cycle

abc = 'abcdefghijklmnopqrstuvwxyz'

def encode(message, key):
    key = cycle(int(x) for x in str(key))
    return [abc.index(m)+1+k for m, k in zip(message, key)]

def encode(message, key):
    a=[]
    key=str(key)
    for i in range(len(message)):
        print(i)
        a.append(ord(message[i])-96 + int(key[i%len(key)]))
    return a

def encode(message, key):
    abc_dict = {
        'a': 1, 'b': 2,  'c': 3, 'd': 4, 'e': 5, 'f': 6,
        'g': 7, 'h': 8,  'i': 9, 'j': 10, 'k': 11, 'l': 12, 'm': 13,
        'n': 14, 'o': 15, 'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20,
        'u': 21, 'v': 22,  'w': 23,  'x': 24,  'y': 25,  'z': 26
        }
    num_list = []
    key_list = str(key)
    x = 0
    for i in message:
        num_list.append(abc_dict[i] + int(key_list[x]))
        x += 1
        if x >= len(key_list):
            x = 0
            
    return num_list

from itertools import cycle
from typing import List


def encode(message: str, key: int) -> List[int]:
    return [ord(m) - 96 + k for m, k in zip(message, cycle(list(map(int, str(key)))))]


def encode(message, key):
    base_dict = {}
    alpha = "abcdefghijklmnopqrstuvwxyz"
    for i in range(26):
        base_dict[alpha[i]]  =  i + 1

    key_extended = []
    count = 0
    for i in range(len(message)):
        try :
            key_extended.append(int(str(key)[count]))
        except IndexError :
            count = 0
            key_extended.append(int(str(key)[count]))
        count += 1

    encrypt = []
    for letter in message:
        encrypt.append(base_dict[letter])

    code = []
    for i in range(len(encrypt)):
        code.append(encrypt[i] + key_extended[i])

    return code

from itertools import cycle

def encode(message, key):
    key = cycle(map(int, str(key)))
    return [ord(c)-96+next(key) for c in message]

def encode(message, key):
    return [ord(sym)-96+int(str(key)[i%len(str(key))]) for i, sym in enumerate(message)]

encode=lambda m,k:[ord(a)-96+int(b)for a,b in zip(m,str(k)*30)]

def encode(message, key):
    key_digs = [int(dig) for dig in str(key)]
    result = [
        ord(ch) - 96
        + key_digs[i % len(key_digs)]
        for i, ch in enumerate(message)
    ]
    
    return result

import string as st
letras = st.ascii_lowercase
def encode(message, key):    
    codif_1 = [letras.index(l)+1 for l in message]
    key_list = [int(l) for l in str(key)]
    n = int(len(message)/len(key_list))
    r = len(message)%len(key_list)
    mascara = key_list * n + key_list[:r+1]
    return [codif_1[i]+mascara[i] for i in range(len(codif_1))]

def encode(message, key):
    key=str(key)
    return [ord(message[i])-96+int(key[i%len(key)]) for i in range(0, len(message))]

encode=lambda m,k: (lambda k: [ord(l)-96+int(k[i%len(k)]) for i,l in enumerate(m)])(str(k))

import string
import numpy as np 

alpha = list(string.ascii_lowercase)
values = list(range(1,27))
dictionary = dict(zip(alpha, values))

def encode(word, old_key):
    key = [int(x) for x in str(old_key)]
    letter_values = []
    for letter in word:
        letter_values.append(dictionary[letter])
    count = 0
    new_list = []
    while count < len(word):
        for number in key:
            if count >= len(word):
                break
            else:
                count += 1
                new_list.append(number)
    key_np = np.array(new_list)
    letter_np = np.array(letter_values)
    final = (key_np + letter_np).tolist()
    return final

def encode(message, key):
    alphabet_number_pairs = {
        'a': 1,
        'b': 2,
        'c': 3,
        'd': 4,
        'e': 5,
        'f': 6,
        'g': 7,
        'h': 8,
        'i': 9,
        'j': 10,
        'k': 11,
        'l': 12,
        'm': 13,
        'n': 14,
        'o': 15,
        'p': 16,
        'q': 17,
        'r': 18,
        's': 19,
        't': 20,
        'u': 21,
        'v': 22,
        'w': 23,
        'x': 24,
        'y': 25,
        'z': 26
        }
    number_list = []
    alphabet_list = str(key)
    a = 0
    for i in message:
        number_list.append(alphabet_number_pairs[i] + int(alphabet_list[a]))
        a += 1
        if a >= len(alphabet_list):
            a = 0
    return number_list

def encode(message, key):
    cypher = {chr(ord('a') + i) : i+1 for i in range(26)}
    return [ cypher[letter] + int(str(key)[i % len(str(key))]) for i, letter in enumerate(message) ]
     


def encode(message, key):
    return [ord(s)-96+int(str(key)[i%len(str(key))]) for i,s in enumerate(message)]

from itertools import cycle
def encode(message, key):
    a = cycle(str(key))
    return [(ord(x)-96) + int(next(a)) for x in message]


from decimal import Decimal
from itertools import cycle

def encode(message, key):
    key_digits = cycle(Decimal(key).as_tuple().digits)
    return [ord(c.lower()) - ord('a') + next(key_digits) + 1 for c in message]

from itertools import cycle

def encode(message, key):
    c = cycle(str(key))
    
    return [ord(i) + int(ord(next(c))) - 144 for i in message]

def dist_from_prev_a(x):
    return ord(x)-ord('a')+1

def encode(message, key):
    x=[dist_from_prev_a(i) for i in message]
    y=list(str(key)*len(message))[:len(message)]
    return [x[i]+int(y[i]) for i in range(len(x))]


def encode(message, key):
    ret = []
    d = dict()
    [d.update({chr(i):i-96}) for i in range(97,123)]
    for i in range(len(message)):
        ret.append(d[message[i]]+int(str(key)[i%len(str(key))]))
    return ret


def encode(message, key):
    mess = list(map(lambda x: ord(x)-96, message))
    str_key = [int(i) for i in str(key)]
    for i in range(0, len(mess)):
        mess[i] = mess[i] + str_key[i % len(str_key)]
    
    return mess

from itertools import cycle
alphabet_numbers = {'a': 1, 'b': 2, 'c': 3, 'd': 4,                        
                    'e': 5, 'f': 6, 'g':7, 'h': 8,
                    'i': 9, 'j': 10, 'k': 11, 'l': 12,
                    'm': 13, 'n': 14, 'o': 15, 'p': 16,
                    'q': 17, 'r': 18, 's': 19, 't': 20,
                    'u': 21, 'v': 22, 'w': 23, 'x': 24,
                    'y': 25, 'z': 26
                    }
def encode(message, key):
    key = str(key)
    key_cycle = cycle(map(int, key)) 
    lst = []
    for letter in message:
        if letter in alphabet_numbers:
            lst.append(alphabet_numbers.get(letter) + next(key_cycle))
    return lst

def encode(message, key):
    
    z = [int(i) for i in str(key)]
    x = 0
    sol = []
    
    for i in message:
        
        if x == len(z):
            x = 0
        sol.append(ord(i)-96+z[x])
        x+=1
    
    return sol

def encode(message, key):
    
    abc = "a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z".split("  ")
    cypher = []
    key = str(key)
    for i, letter in enumerate(list(message)):
        letterToDigit = abc.index(letter) + 1        
        addedKeyIndex = i % len(key)
        addedKeyValue = key[addedKeyIndex]
        cypher.append(letterToDigit + int(addedKeyValue))
    return cypher
        
    


def encode(message, key):
    key = list(str(key))
    alpha = list("0abcdefghijklmnopqrstuvwxyz")
    message = list(message)
    code = [alpha.index((message[i])) for i in range(len(message)) if message[i] in alpha]
    i = -1
    for j in range(len(code)):
        if i == len(key)-1:
            i = -1
        i += 1
        code[j] = code[j]+int(key[i])

    return code



def encode(message, key):
    # Code here
    al = "abcdefghijklmnopqrstuvwxyz"
    key = str(key)
    if len(message) > len(key): key = key*int(len(message)/len(key) + 1)
    out = []
    for i in list(message): out.append(al.index(i) + 1)
    for i in range(len(out)): out[i] = out[i] + int(key[i])
    return out

def encode(message, key):
    dicti = {}
    code = []
    ans = []
    letters = list(message)
    alphabet = list('abcdefghijklmnopqrstuvwxyz')
    for i in range(len(alphabet)):
        dict_ = {alphabet[i]: i+1}
        dicti.update(dict_)
    for letter in letters:
        for k, v in dicti.items():
            if k == letter:
                code.append(v)
    key_list = list(str(key))
    a = len(message) // len(key_list)
    if len(message) > len(key_list):
        key_list = key_list * (a + 1)
    for j in range(len(code)):
        if j < len(message):
            new_code = code[j] + int(key_list[j])
            ans.append(new_code)
        elif j == len(message):
            break
    #print(ans)
    return ans

def encode(message, key):
    key = [int(k) for k in str(key)]
    l = len(key)
    return [ord(c) - 96 + key[i % l] for i, c in enumerate(message)]

def encode(message, key):
    alphabet = 'abcdefghijklmnopqrstuvwxyz'
    alphabet = list(alphabet)
    letters_numbers = {}
    for i in range(len(alphabet)):
        dict_ = {alphabet[i]: i+1}
        letters_numbers.update(dict_)
    message_numbers = []
    for j in message:
        number = letters_numbers[j]
        message_numbers.append(number)
    key = str(key)
    key = list(key)
    final_message_encoded = []
    for k in range(len(message)):
        key.append(key[k])
    for l in range(len(message_numbers)):
        message_encoded = message_numbers[l] + int(key[l])
        final_message_encoded.append(message_encoded)
    return final_message_encoded




def encode(word, key):
    vo = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8, 'i': 9, 'j': 10,
    'k': 11, 'l': 12, 'm': 13, 'n': 14, 'o': 15, 'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20,
    'u': 21, 'v': 22, 'w':23, 'x': 24, 'y': 25, 'z': 26}
    kk = list(map(int, str(key)))
    kk = kk * int((len(word) / len(kk) + 1))
    k = list(word)
    arr = []
    for i in k:
            arr.append(vo.get(i))
    for j in range(len(arr)):
            arr[j] += kk[j]
    return arr

def encode(s,k):
    eng = '_abcdefghijklmnopqrstuvwxyz'
    b = list(map(int, list(str(k))))
    q, r = divmod(len(s), len(str(k)))
    return list(map(lambda x, y: x+y, b*q+b[:r], list([eng.index(_) for _ in s])))


def encode(message, key):
    key=str(key)
    return [ord(message[i])-96+int(key[i%len(key)]) for i in range(len(message))]

def encode(message, key):
    k = [int(x) for x in str(key)]
    l = len(k)

    return [n+k[i%l] for i,n in enumerate(ord(c)-96 for c in message)]

def encode(m, key):
    k = list(map(int, list(str(key))))
    kL = len(k)
    m = list(m)
    for i in range(len(m)):
        m[i] = ord(m[i]) - 96 + k[i % kL]
    return m

def encode(message, key):
    letters = {chr(97+x):x+1 for x in range(28)}
    return [letters[l]+int(add) for l,add in zip(message, list(str(key)) * len(message) )]

from itertools import cycle
def encode(message, key):
    letters = []
    fullkey = [int(x) for x in str(key)]
    for character in message:
        number = ord(character) - 96
        letters.append(number)
    outcome = [x+y for x, y in zip(letters, cycle(fullkey),)]
    return outcome

def encode(message, key):
    import string
    
    alphabet=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
    # étape 1 : conversion du message en nombres
    code=[]
    for i in range(len(message)):
        code += [alphabet.index(message[i])+1]
    # étape 2: on ajoute la clef
    keystr=str(key)
    for i in range(len(code)):
        code[i] += int(keystr[i % len(keystr)])
    
    return code 
    
        


def encode(m,k):
    d = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8, 'i': 9, 'j': 10, 'k': 11, 'l': 12, 'm': 13, 'n': 14, 'o': 15, 'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20, 'u': 21, 'v': 22, 'w': 23, 'x': 24, 'y': 25, 'z': 26}
    
    count = 0
    l = []
    p = []
    n = []
    st = str(k)
    lst = list(st)
    for x in range(len(m)):
        num = d.get(m[x])
        l.append(num)
    
    while count < len(l):
    
        for y in range(len(lst)):
               if count < len(l):
                    p.append(int(lst[y]))
                    count = count + 1
               else:
                   break
                   
    for z in range(len(l)):
            calc = l[z] + p[z]
            n.append(calc)
    
    return n
  



encode = lambda m, k :[ord(d)-ord('a')+1 + int(str(k)[i%len(str(k))]) for i, d in enumerate(m)]

from collections import deque

def encode(message, key):
    out = []
    key = deque(map(int, str(key)))
    for c in message:
        out.append(ord(c) - 96 + key[0])
        key.rotate(-1)
    return out

def encode(message: str, key):
    return [ord(x) - 96 + int((str(key)[i % len(str(key))])) for i, x in enumerate(message.lower())]

import string

map = {ch: i + 1 for i, ch in enumerate(string.ascii_lowercase)}

def encode(message, key):    
    key = str(key)   

    res = []
    for i, ch in enumerate(message):
        res.append(map[ch] + int(key[i % len(key)]))
        
    return res


def encode(message, key):
    num = []
    key = str(key)
    length = len(key)
    for i in range (0,len(message)):
        num.append(((ord(message[i]) - 96) + (ord(key[i%length]) - 48)))
    print (num)
    return num

def encode(message, key):
    message = message.lower()
    key = list(str(key))
    message = list(message)
    for i in range(len(message)):
        message[i] = (ord(message[i]) - 96) + (int(key[i % len(key)]))
    return message

def encode(message, key):
    
    indexKey = 0 
    l = [ord(m)- 96 for m in message]

    for i in range(len(message)):       
        l[i] +=  int ( str(key)[indexKey] )
        indexKey =  ( indexKey + 1) % len(str(key))
        
    return l
        


def encode(message, key):
    return [i + int(l) for i, l in zip([' abcdefghijklmnopqrstuvwxyz'.index(i) for i in message], str(key) * (len(message) // len(str(key))) + str(key)[:len(message) % len(str(key))])]

def encode(message, key):
    x = [ord(i) - 96 for i in message]
    x = [x[i] + int(str(key)[i % len(str(key))]) for i in range(len(x))]
    return x

def encode(message, key):
    arr = []
    for i in range(len(message)):
        encr = ord(message[i]) - 96
        if i > len(str(key)) - 1:
            k = i - len(str(key))*(i // len(str(key)))
        else:
            k = i            
        arr.append(encr + int(str(key)[k]))

    return arr

def encode(msg, k):
    return [ord(m)-96+int(str(k)[i%len(str(k))]) for i,m in enumerate(msg)]

def encode(message, key):
#    alphabet = {
#    'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5, 'f' : 6, 'g' : 7, 'h' : 8, 'i' : 9,
#    'j' : 10, 'k' : 11, 'l' : 12, 'm' : 13, 'n' : 14, 'o' : 15, 'p' : 16, 'q' : 17,
#    'r' : 18, 's' : 19, 't' : 20, 'u' : 21, 'v' : 22, 'w' : 23, 'x' : 24, 'y' : 25,
#    'z' : 26
#    }
    key_tracker = 0
    ciphertext = []
    key = [int(k) for k in str(key)]
    letters = [ord(a)-96 for a in message]
    for i in range(len(letters)):
        letters[i] += key[key_tracker]
        key_tracker += 1
        if key_tracker == len(key):
            key_tracker = 0
    return letters

from string import ascii_lowercase as alpha
def encode(message, key):
    first = [alpha.index(x)+1 for x in message]
    n,k = len(message),str(key)
    return [first[i]+int(k[i%len(k)]) for i in range(n)]

from itertools import cycle

def encode(message, key):
    key = list(map(int, str(key)))
    return [ord(c) - 96 + k for c, k in zip(message, cycle(key))]

def encode(message, key):
    key = list(map(int, str(key)))
    return [ord(c) - 96 + key[i % len(key)] for i, c in enumerate(message)]

def encode(message, key):
    message = [ord(x) - 96 for x in message]
    key = str(key)

    key_list = list(key)
    x = list(key)
    while len(key_list) != len(message):
        if not x:
            x = list(key)
        key_list.append(x.pop(0))

    return [message[i] + int(x) for i, x in enumerate(key_list)]

from itertools import chain, repeat

alpha = 'abcdefghijklmnopqrstuvwxyz'

def encode(message, key):
    message_l = [(alpha.index(c)+1) for c in message]
    key_l = [i for i in chain.from_iterable(repeat([int(num) for num in str(key)], 100))]
    return [(message_l[i] + key_l[i]) for i in range(len(message_l))]
        


def encode(message, key):
    return [ord(j)-96+int((str(key)*(len(message)//len(str(key))+1))[i]) for i, j in enumerate(message)]

def encode(message, key):
    ans = [] ;key = list(str(key)); counter = 0
    for i in message:
        if counter == len(key):
            counter = 0
        ans.append(ord(i)-96 + int(key[counter]))
        counter +=1
    return ans


def encode(message, key):
    return [ord(message[a]) - 96 + (int(str(key)[a%len(str(key))])) for a in range(len(message))]

def encode(message, key):
    key = str(key)
    output = []
    for i in range(0, len(message)):
        output.append( ord(message[i]) - 96 + int(key[i%len(key)]) )
    return output

def encode(message, key):
    #horrible, but today felt like a one-liner kind of day
    return [ord(c) - 96 + int(str(key)[i%len(str(key))]) for i, c in enumerate(message)]


def encode(message, key):
    msgnumber = [ord(m) - 96 for m in message]
    key = (str(key) * int((len(message) / len(str(key)))+1))[:len(message)]
    key = [int(k) for k in key]
    return [m + k for m, k in zip(msgnumber, key)]

def encode(message, key):
    alpha = {'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':10,'k':11,'l':12,'m':13,'n':14,'o':15,'p':16,'q':17,'r':18,'s':19,'t':20,'u':21,'v':22,'w':23,'x':24,'y':25,'z':26}
    count = 0
    value = 0
    res = []
    n = len(message)
    key_index = list(i for i in str(key))
    m_index = list(j for j in message)
    m = len(str(key))-1
    while count < n:
        res.append(alpha[m_index[count]] + int((key_index[value])))
        if value == m:
            value = 0
        else:
            value += 1
        count += 1
    print(res)
    return res

def encode(message, key):
    return [ord(message[x])-96+int(str(key)[x%len(str(key))]) for x in range(0,len(message))]

def encode(message, key):
    alphakey = {
        'a': 1,'b': 2,'c': 3,'d': 4,'e': 5,
        'f': 6,'g': 7,'h': 8, 'i': 9,'j': 10,
        'k': 11,'l': 12,'m': 13,'n': 14,'o': 15,
        'p': 16,'q': 17,'r': 18,'s': 19,'t': 20,
        'u': 21,'v': 22,'w': 23,'x': 24,'y': 25,'z': 26
    }
    itakey = str(key)
    n = 0
    ans = []
    while n < len(message):
        ans.append(int(itakey[n%len(itakey)]) + alphakey[message[n]])
        n += 1
    return ans
        
        


def encode(message, key):
    pre_output = []
    for letter in message:
        pre_output.append(ord(letter)-96)
    output = []
    key = str(key)
    i = 0
    for number in pre_output:
        output.append(number+int(key[i]))
        if i == len(key) - 1:
            i = 0
        else:
            i += 1
    return output

def encode(m, k):
    k = map(int, (str(k)*(len(m)//len(str(k))+1))[:len(m)])
    return list(map(sum,zip([ord(x)-96 for x in m],k)))

def encode(message, key):
    key = list(str(key) * (len(message)//len(str(key))+1)) if len(str(key)) < len(message) else list(str(key))
    encode_list = []
    key_index = 0
    for i in list(message):
        encode_list.append(ord(i) - 96 + int(key[key_index]))
        key_index += 1
    return encode_list

from itertools import cycle

def encode(message, key):
    
    a = []

    for m,c in zip(message,cycle(str(key))):

        d = ord(m)-96 + int(c)

        a.append(d)
        
    return a


def encode(message, key):
    import string
    alphabet = enumerate(string.ascii_lowercase, 1)

    dic_letters = {k: v for v, k in alphabet}

    numbers = [dic_letters[letter] for letter in message]

    lst_key = len(message)*[int(x) for x in str(key)]

    lst_zip = list(zip(numbers, lst_key))

    return list(sum(group) for group in lst_zip)

def encode(message, key):
    k = [int(x) for x in str(key)]
    return [ord(message[x])-96+k[x%len(k)] for x in range(len(message))]

def encode(message, key):
    a = []
    j = 0
    for i in message:
        a.append(ord(i)-96 + int(str(key)[j]))
        j += 1
        if j == len(str(key)):
            j = 0
    return a

def encode(message, key):
    key_list = list(str(key))
    encoded_list = []
    k = 0
    for letter in message:
        
        letter_digit = ord(letter) - 96
        
        letter_digit_encoded = letter_digit + int(key_list[k%len(key_list)])
        
        encoded_list.append(letter_digit_encoded)
        
        k += 1
        
    return encoded_list
        


def encode(message, key):
    res = []
    db = {chr(i): i-96 for i in range(97, 123)}
    zippand1 = [db[i] for i in message]
    zippand2 = list(map(int, str(key))) * len(str(message))
    return [i+j for i,j in zip(zippand1, zippand2[:len(message)])]

def encode(message, key):
    arr = []
    for i in range(len(message)):
        arr.append(ord(message[i]) - 96 + int(str(key)[i % len(str(key))]))
    return arr
    


def encode(message, key):
    coded_message = [ord(char) - 96 for char in message]
    return [digit + int(str(key)[index % len(str(key))]) for index, digit in enumerate(coded_message)]

def encode(message, key):
    val =  [ord(i) - 96 for i in message]
    check = str(key)
    index = 0
    for idx, i in enumerate(val):
        if idx % len(check) == 0:
            index = 0
        val[idx] += int(check[index])
        index += 1

    return val

def encode(message, key):
    L1="abcdefghijklmnopqrstuvwxyz";L2=[];number=0;L3=[]
    for i in message:
        L2.append(L1.index(i)+1+int(str(key)[number%len(str(key))]))
        number+=1
    return L2 
    
    


from itertools import cycle
def encode(message, key):
    return [ord(c)- 96 + int(k) for c,k in zip(message, cycle(str(key)))]

def encode(message, key):
  strKey = str(key)
  return [ord(letter) - 96 + int(strKey[index % len(strKey)]) for index, letter in enumerate(message)]
    
    
    


import string 
from itertools import cycle  

def encode(message, key):
  alphabet = dict(zip(string.ascii_lowercase, (ord(i) - 96 for i in string.ascii_lowercase)))
  key = cycle([int(i) for i in str(key)])
  res = []
  for i in message:
    encoding = int(alphabet.get(i)) + next(key)
    res.append(encoding)
  return res

def encode(m, key):
    array_key = []
    list_int_str_key = [int(x) for x in str(key)]
    len_str_key = len(list_int_str_key)
    ords_list = [ord(x)-96 for x in m]
    len_ords_list = len(ords_list)
    i = 0
    while len(array_key) < len_ords_list:
        array_key.append(list_int_str_key[i])
        i += 1
        if i >= len_str_key: i = 0

    return [a+b for a,b in zip(array_key, ords_list)]

from string import ascii_lowercase as abc
from itertools import cycle

def encode(message, key):
    return [abc.index(m)+k+1 for m, k in zip(message, cycle(map(int, str(key))))]

from string import ascii_lowercase as abc
from itertools import cycle


def encode(message, key):
    return [int(x) + abc.index(ch)+1 for x, ch in list(zip(cycle(str(key)), message))]

from string import ascii_lowercase as abc
from itertools import cycle


def encode(message, key):
    ch_idx = [abc.index(ch)+1 for ch in message]
    return [int(x) + y for x, y in list(zip(cycle(str(key)), ch_idx))]

from itertools import cycle 
def encode(message, key):
    # Code here
    return [a + b for a, b in zip(cycle([int(i) for i in str(key)]), [ord(i)-96 for i in message])]

def encode(message, key):
    cypher = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6, 'g':7, 'h':8, 'i':9, 'j':10, 'k':11, 'l':12,
    'm':13, 'n':14, 'o':15, 'p':16, 'q':17, 'r':18, 's':19, 't':20, 'u':21, 'v':22, 'w':23, 'x':24,
    'y':25, 'z':26}
    output = []
    for i in range(len(message)):
        code = cypher[message[i]]
        i = i % len(str(key))
        code += int(str(key)[i])
        output.append(code)
    return output

def encode(message, key):
    key = str(key) * len(message)
    return ['abcdefghijklmnopqrstuvwxyz'.index(m) + int(key[i]) + 1  for i ,m in enumerate(message)]
        


from itertools import cycle
def encode(message, key):
    return [v+int(v1) for v,v1 in zip([ord(c) - 96 for c in message], cycle(str(key)))]

def encode(message, key):
    return [ord(c)-ord('`')+int(str(key)[i % len(str(key))]) for i,c in enumerate(message)]

def encode(message, key):
    fuck = [(ord(x) - 96) for x in message]
    cunt = [int(x) for x in str(key)]
    for index, cum in enumerate(fuck):
        fuck[index] += cunt[index % len(str(key))]
    return fuck

from string import ascii_lowercase as alpha
def encode(message, key):
    key = (len(message) // len(str(key)) + 1) * str(key)  
    return [alpha.index(c) + int(k) + 1 for c, k in zip(message, key)]

from string import ascii_lowercase as letters

def encode(message, key):
    return [letters.index(m) + int(k) + 1 for m, k in zip(message, f'{key}' * len(message))]