Create a function with two arguments that will return an array of the first (n) multiples of (x). 

Assume both the given number and the number of times to count will be positive numbers greater than 0. 

Return the results as an array (or list in Python, Haskell or Elixir).

Examples:

```python
count_by(1,10) #should return [1,2,3,4,5,6,7,8,9,10]
count_by(2,5) #should return [2,4,6,8,10]
```

Difficulty: introductory

Starter code:

def count_by(x, n):
	

Solutions:
def count_by(x, n):
    return [i * x for i in range(1, n + 1)]

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    return [i * x for i in range(1, n+1)]


def count_by(x, n):
    return [x * i for i in range(1, n+1)]

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    return list(range(x, n * x + 1, x))


def count_by(x, n):
    arr = []
    for num in range(1, n+1):
        result = x * num
        arr.append(result)
    return arr


def count_by(x, n):
    """Return a sequence of numbers counting by `x` `n` times."""
    return list(range(x, (n+1)*x, x))


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    num = x
    results = [x]

    for i in range(n-1):
        num += x
        results.append(num)

    return results
        


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    my_list = []
    for number in range(1, n + 1):
        my_list.append(x*number)
    return my_list

count_by = lambda x,y: list(range(x,x*y+1,x))

def count_by(x, n):
    return [i for i in range(x, x * (n + 1), x)]

count_by = lambda x,n : list(range(x,n*x+1,x))
    


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    return [(d+1)*x for d in range(n)]

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    return [e for e in range(x, x * n + x, x)]
   


count_by = lambda x, n: [x * r for r in range(1, n + 1)]


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    output = []
    i = 1
    while len(output) < n:
        output.append(i*x)
        i += 1
    return output

count_by = lambda x, n: list([(a + 1) * x for a in range(n)])


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    lst = []
    y = 0
    while len(lst) < n:
        y += x
        lst.append(y)
    return lst

from typing import List

def count_by(x: int, n: int) -> List[int]:
    """ Return a sequence of numbers counting by `x` `n` times. """
    return list(range(x, x * n + 1, x))

def count_by(x, n):
    count =[]
    for i in  range(1, n+1):
        count += [i*x]
    return count


def count_by(x, n):

    multiples = [mb * x for mb in range(1, n+1)]
    
    return multiples 


def count_by(x, n):
    x1 = x
    res = []
    for i in range(n):
        res.append(x)
        x += x1
    return res


def count_by(x, n):
    lista = []
    d = x
    for i in range(n):
        lista.append(x)
        x += d
    return lista


def count_by(x, n):
    i = 0
    arr = [0] * n
    for i in range(n):
        arr[i] = x * (i+1)
    return arr

def count_by(x, n):
    array = []
    
    for i in range(x, n*x+1, x):
        array.append(i)
        
    return array
        
    
    
    
    


def count_by(a, n):
    list =[]
    for x in range(1, n+1):
        list.append(x)
    list2=[]
    for x in list:
        list2.append(x*a)
    return list2


def count_by(x, n):
    return list(range((n+1)*x)[::x])[1:]


def count_by(x, n):
    
     x = list(range(x,n*x+1,x))
     return x





def count_by(x, n):
    return [i for i in range(0, n*x+1, x)][1:]

def count_by(x, n):
    multiples_of_x = []
    for number in range(1, n + 1):
       multiples_of_x.append(number * x)
    
    return multiples_of_x
    """
    Return a sequence of numbers counting by `x` `n` times.
    """


def count_by(x, n):
    y = []
    ind = 1
    for i in range(n):
        y.append((x * ind))
        ind += 1
    return y

def count_by(x, n):
    i = 0
    number = 0
    list = []
    while i < n:
        i += 1
        number += x
        list.append(number)
    return list


def count_by(x, n):
    arr = []
    for num in range(x, x * (n + 1), x):
        arr.append(num)
    return arr


def count_by(x, n):
    lis = []
    i = 1
    while i <= n:
        a = x*i
        i+=1
        lis.append(a)
    return lis


def count_by(x, n):
    output=[]
    for i in range(n):
        output.append((i+1)*x)
    return output
   


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    array = []
    number = 0
    m = x
    while number < n:
        array.append(m)
        m += x
        number += 1
    return array

def count_by(x, n):
    return list(range(0, (n+1)*x, x)[1:])

print(count_by(2, 5))

def count_by(x, n): 
    mul = x * n
    arr = [i for i in range(x, mul + 1, x)]
    return arr


count_by=lambda x,n:[*range(x,x*n+x,x)]

def count_by(x, n):
    return [i for i in range(0+x , n*x+x, x)]
    """
    Return a sequence of numbers counting by `x` `n` times.
    """


def count_by(x, n):
    arr = [0]
    for i in range(n):
        arr.append(arr[-1] + x)
    return arr[1:]

def count_by(x, n):
    i = 1
    count_list = []
    while i <= n:
        count_list.append(x * i)
        i += 1
    return count_list
        


def count_by(x, n):
    number = []
    for i in range(1,n+1):
        num = x*i
        number.append(num)
    return number


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    lis = []
    i = 1
    while len(lis) < n:
        if i % x == 0:
            lis.append(i)
        i += 1
    
    return lis


def count_by(x, n):
    multiplier = [i for i in range(1, (n + 1))]
    return [x * y for y in multiplier]

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    
    count = []
    total = 0
    
    while n > 0:
        total += x
        count.append(total)
        n -= 1
    
    return count


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    product = x*n
    result =list(range(x,product+1,x))
    return result 


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    return list(x * n for n in range(1,n+1))


def count_by(x, n):
    arr = []
    collect = x
    for i in range(n):
        arr.append(collect)
        collect += x
        
        
    return arr


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    
    list = []
    y = x
    
    while len(list) < n:
        list.append(y)
        y += x
        
    return list

def count_by(x, n):
    result = []
    y=1
    for number in range (n):
        result.append(x*y)
        y += 1
    return result


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    r = []
    z = 1
    while z <= n:
        y = x * z
        r.append(y)
        z = z + 1
    return r

def count_by(x, n):
    counter = 0
    multiples = []
    i = 1
    while counter < n :
        if i % x == 0:
            counter += 1
            multiples.append(i)
        i += 1
        
    return multiples


def count_by(x, n):
    ans = []
    i = x
    count = 0
    while count < n:
        ans.append(i)
        i += x
        count += 1
    return ans 

def count_by(x, n):
    answer = []
    for x in range(x, n*x + x, x):
        answer.append(x)
    return answer


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    y = x
    df = []
    i = 1
    while i < n+1:
        x = x
        df.append(x)
        x = x+y
        i += 1
    return df

def count_by(x, n):
    i=1
    return [i*x for i in range(n+1)[1:]]

count_by = lambda x, n:list(range(x,(n+1)*x,x))

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    res = []
    num = x
    while n > 0:
        res.append(num)
        num += x
        n -= 1
    return res


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    new_list = []
    tracker = 1
    
    while tracker <= n:
        new_list.append(tracker * x)
        tracker += 1
    
    return new_list
        


def count_by(x, n):
    p1 = list(range(x, (x*n+1), x))
    return p1


def count_by(x, n):
    a = [i for i in range(x, x*n + 1) if i % x == 0]
    return a[:n + 1]


from typing import List, Union

def count_by(x: Union[int,float], n: int) -> List[Union[int,float]]:
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    return [x*it for it in range(1,n+1)]


count_by = lambda start, end: list(range(start, start*end+1, start))


def count_by(x, n):
    count = 1
    i = 1
    L = []
    while count <= n:
        if i % x == 0:
            L.append(i)
            count += 1
        i += 1
    return L


def count_by(x, n):
    a = x*n
    s = []
    for i in range(x,a+1):
        if i%x == 0:
            s.append(i)
    return s


def count_by(x, n):
    start = x
    result = list()
    while start <= x * n:
        result.append(start)
        start += x
    return result

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    if x == 1:
        return [x for x in range(x, n+1)]
    else:
        y = [x, (n*x)]
        z = []
        for j in range(1, n+1):
            z.append(y[0]*j)
        return z


def count_by(x, n):
    list = []
    for i in range(1,n+1):
        a = x*i
        list.append(a)
        i += 1
    return list


def count_by(x, n):
    return list(map(lambda num: x  * num, range(1, n + 1)))

def count_by(x, n):
    res = []
    sum = 0
    for i in range(n):
        sum += x
        res.append(sum)
    return res

def count_by(n, x):
    results=[]
    s=n
    for i in range (1, x+1):
        results.append(s)
        s=s+n
    return results

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    res = []
    c = 0
    for i in range(n):
        c += x
        res.append(c)
    return res

count_by = lambda x,y: [x*i for i in range(1,y+1)]

def count_by(x, n):
    y = x
    result = [x]
    for i in range(n-1):
        y += x
        result.append(y)
    return result


def count_by(x, n):
    list = []
    for multiplier in range(n):
        list.append(x*(multiplier+1))
    return list
        


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    result = (x*z for z in range(1,n+1))
    """
    for z in range(1,n+1):
        result.append(x*z)
    """
    return list(result)

def count_by(x, n):
    """
        Returns a sequence of numbers counting by 'x' 'n' times.
    """
    return [num for num in range(x, x * n + 1, x)]

def count_by(x, n):
    
# =============================================================================
#     This function given two arguments returns an array of the first (n) multiples of (x). 
# 
#     Both the given number and the number of times to count will be positive 
#     numbers greater than 0.
#     
#     The function returns the result as a list.
#     Examples:
#         count_by(1,10) ==> [1,2,3,4,5,6,7,8,9,10]
#         count_by(2,5) ==>  [2,4,6,8,10]
# =============================================================================
        
    result = []
    
    for n in range(1,(n+1)):
        result.append(n * x)
    
    return result


def count_by(x, n):
    result = list();
    temp = x
    for i in range(n):
        result.append(x)
        x += temp
    return result    

def count_by(x, n):
    l=[]
    z=x
    for i in range (0,n):
        l.append(x)
        x+=z
    return l

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    new_list = []
    y = 0
    for count in range(n):
        new_list.append(y + x)
        y = (y + x)
    return new_list

def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    i = 1
    rl = []
    while i <= n:
        rl.append(i*x)
        i += 1
    return rl

def count_by(x, n):
    return [n for n in list(range(x, n*x + 1, x))]

def count_by(x, n):
    multiplesList = []
    for i in range(1,n+1): 
        multiplesList.append(x*i)
    return multiplesList


def count_by(x, n):
    """
    Return a sequence of numbers counting by `x` `n` times.
    """
    w = []
    k = 0
    for i in range(n):
        k = k + x
        w.append(k)
    return w


def count_by(x, n):
    min = x
    arr = [x]
    for i in range(n-1):
        min += x
        arr.append(min)
    return arr


def count_by(x, n):
    numbers = []
    for i in range(x,x*n+x,x):
        numbers.append(i)
    return numbers

def count_by(x, n):
    curr = range(x, (x*n)+x, x)
    list = []
    for x in curr:
        list.append(x)
    return list

def count_by(x, n):
    '''Listen little mukas, I know this isnt the most elegant but I'm exhausted'''
    return [element*x for element in list(range(1,n+1))]

def count_by(x, n):
    array = []
    for n in range(1, n+1):
        array.append(x*n)
    return array


def count_by(x, n):
    return list(i for i in range(x,x*n+1,x))


def count_by(x, n):
    count = 1
    value = 0
    numberList = []
    while count <= n:
        value = value + x
        numberList.append(value)
        count = count + 1
    return numberList
        
        
        
        


def count_by(x, n):
    list_result = []
    last_entry = 0
    for i in range(n):
        last_entry += x
        list_result.append(last_entry)
    return list_result
    """
    Return a sequence of numbers counting by `x` `n` times.
    """


def count_by(x, n):
    my_List = list(range(x, (n*x)+x, x))
    return my_List


def count_by(x, n):
    counter = 1
    s = 0
    lst = []
    while counter <= n:
        s += x
        lst.append(s)
        counter += 1
    return lst

def count_by(n, x):
    return [i for i in range(n, (x + 1) * n) if i % n == 0]