~~~if:csharp,javascript,cfml,php
Given a 2D array of size `m * n`. Your task is to find the sum of minimum value in each row.
~~~
~~~if:cpp
Given a 2D vector of size `m * n`. Your task is to find the sum of minimum value in each row.
~~~
~~~if:python,ruby
Given a 2D list of size `m * n`. Your task is to find the sum of minimum value in each row.
~~~

For Example:
```python
[
  [1, 2, 3, 4, 5],       # minimum value of row is 1
  [5, 6, 7, 8, 9],       # minimum value of row is 5
  [20, 21, 34, 56, 100]  # minimum value of row is 20
]
```
So, the function should return `26` because sum of minimums is as `1 + 5 + 20 = 26`

~~~if:javascript,php
Note: You will be always given non-empty array containing Positive values.
~~~
~~~if:python
Note: You will be always given non-empty list containing Positive values.
~~~
~~~if:cpp
Note: You will be always given non-empty vector containing Positive values.
~~~
~~~if:c#
Note: You will be always given non-empty vector containing Positive values.
~~~
~~~if:cfml
Note: You will be always given non-empty array containing Positive values.
~~~

ENJOY CODING :)

Difficulty: introductory

Starter code:

def sum_of_minimums(numbers):
	

Solutions:
def sum_of_minimums(numbers):
    return sum(map(min, numbers))

def sum_of_minimums(numbers):
    return sum([min(rows) for rows in numbers])

def sum_of_minimums(numbers):
    return sum(min(xs) for xs in numbers)

def sum_of_minimums(numbers):
    total = 0
    for nums in numbers:
        total += min(nums)
    return total

def sum_of_minimums(numbers):
    return sum(min(row) for row in numbers)

def sum_of_minimums(a):
    return sum(map(min, a))

def sum_of_minimums(numbers):
    
    answer = []
    
    for array in numbers:
        answer.append(min(array))
        
    return sum(answer)

def sum_of_minimums(numbers):
    return sum(min(v)for v in numbers)

def sum_of_minimums(numbers):
    return sum([min(x) for x in numbers])

def sum_of_minimums(numbers):
    return sum([min(l) for l in numbers])

def sum_of_minimums(numbers):
    return sum([min(i) for i in numbers])

from typing import List

def sum_of_minimums(numbers: List[int]) -> int:
    """ Find the sum of minimum value in each row. """
    return sum(map(min, numbers))


from typing import List

def sum_of_minimums(numbers: List[int]) -> int:
    """ Find the sum of minimum value in each row. """
    return sum([min(_num_list) for _num_list in numbers])


def sum_of_minimums(num): return sum([min(i) for i in num])

sum_of_minimums=lambda l:sum(min(e)for e in l)

def sum_of_minimums(a):
    return sum(min(sub_a) for sub_a in a)

def sum_of_minimums(numbers):
    summ = 0
    for i in numbers:
       x = sorted(i)[0]
       summ+=x

    return summ

def sum_of_minimums(numbers):
    pass
    print(('Input: ', numbers))
    x = 0
    mini = 0
    answer = []
    for i in numbers:
        mini = [min(numbers[x])]
        answer.append(mini)
        x+=1   
    res = [sum(i) for i in zip(*answer)] 
    stringres = [str(i) for i in res]
    finalres = int("".join(stringres))
    return int(finalres)    


def sum_of_minimums(arr):
    return sum(min(lst) for lst in arr)

def sum_of_minimums(a):
    m=[]
    
    for i in a:
        m.append(min(i))
        
    return(sum(m))

def sum_of_minimums(numbers):
    return sum([sorted(x)[0] for x in numbers])

sum_of_minimums = lambda num: sum([sorted(i)[0] for i in num]) #This is a stupid comment from yours truly -Mr. Stupido

def sum_of_minimums(numbers):
    output = 0
    for row in numbers:
        row.sort()
        output += row[0]
    return output    

def sum_of_minimums(numbers):    
    return sum(min(m) for m in numbers)

def sum_of_minimums(numbers):
    return sum([sorted(numbers[i],reverse=True)[-1] for i in range(len(numbers))])

def sum_of_minimums(numbers):
    return sum([min(sub) for sub in numbers])

sum_of_minimums=lambda n:sum(map(min,n))

def sum_of_minimums(numbers):
    results=[]
    for x in numbers:
        results.append(sorted(x)[0])
    return sum(results)


def sum_of_minimums(numbers):
    sum = 0
    for i in range(len(numbers)):
        min = numbers[i][0]
        for j in range(1, len(numbers[i])):
            if numbers[i][j] < min:
                min = numbers[i][j]
        sum += min
    return sum

from functools import reduce

def sum_of_minimums(numbers):
    return reduce(lambda x, y: min(y) + x, numbers, 0)

def sum_of_minimums(numbers):
    minimos = map(min, numbers)
    suma_minimos = sum (minimos)
    return suma_minimos

def sum_of_minimums(numbers):
    ms=0
    
    for i in range(len(numbers)):
        ms+=min(numbers[i])
    return ms

def sum_of_minimums(numbers):
    return sum(sorted(i).pop(0) for i in numbers)

def sum_of_minimums(numbers):
    return sum(sorted(i, reverse=True).pop() for i in numbers)

def sum_of_minimums(numbers):
    new_list = [ ]
    mini = 0
    for i in numbers:
        mini = min(i)
        new_list.append(mini)
    return sum(new_list)

def sum_of_minimums(numbers):
    sum = 0
    for i in numbers:
        new = sorted(i)
        sum += new[0]
    return sum


def sum_of_minimums(n):
    return sum(min(e) for e in n)


def sum_of_minimums(numbers):
    sum = 0
    for n in range(len(numbers)):
        sum += sorted(numbers[n])[0]
    return sum

def sum_of_minimums(numbers):
    s = 0
    for el in numbers:
        min(el)
        s = s + min(el)
    return s

def sum_of_minimums(numbers):
    s = 0
    for el in numbers:
        s = s + min(el)
    return s

def sum_of_minimums(numbers):
    s = 0
    for el in numbers:
        s += min(el)
    return s

def sum_of_minimums(numbers):
    mini = [min(el) for el in numbers]
    return sum(mini)

def sum_of_minimums(numbers):
    count = []
    for n in numbers:
        count.append(min(n))
    return sum(count)


def sum_of_minimums(nums):
    return sum(min(x) for x in nums)


def sum_of_minimums(numbers):
    a = [min(x) for x in numbers]
    return sum(a)

def sum_of_minimums(numbers):
  b = []
  for i in range(0, len(numbers)):
    b.append(min(numbers[i]))
  c = 0
  for j in range (0, len(b)):
    c += b[j]
  return c

def sum_of_minimums(numbers):
    
    total_sum = 0
    i = 0
    while i < len(numbers):
        total_sum += min(numbers[i])
        i += 1
    return total_sum

def sum_of_minimums(numbers):
    min_sum = int()
    for num in numbers:
        min_sum += min(num)
    return min_sum

def sum_of_minimums(numbers):
    mini = []
    for i in range(len(numbers)):
        mini.append(min(numbers[i]))
    return sum(mini)

def sum_of_minimums(nums):
    return sum([min(el) for el in nums])

def sum_of_minimums(numbers):
    rs = 0
    for i in numbers:
        rs += (min(i))
    return rs

import numpy as np
def sum_of_minimums(numbers):
    minimums = []
    for n in numbers:
        minimums.append(np.min(n))
    return np.sum(minimums)

def sum_of_minimums(numbers):
    summ = 0
    
    for i in range(len(numbers)):
        mini = min(numbers[i])
        summ += mini
    return summ

def sum_of_minimums(n):
    c=0
    for i in n:
        c+=min(i)
    return c

def sum_of_minimums(numbers):
    sum=0
    
    for i in range(0,len(numbers)):
         sum=sum+min(numbers[i])
         i=i+1   
            
    return sum



def sum_of_minimums(numbers):
    suma = 0
    for arr in numbers:
        suma += min(arr)
    return suma

def sum_of_minimums(numbers):
    sum1=0
    for nums in numbers:
        sum1+=min(nums)
    return sum1

def sum_of_minimums(numbers):
    here = []
    for el in numbers:
        x = min(el)
        here.append(x)
    return sum(here)


def sum_of_minimums(numbers):
    summ_of_minimums = 0
    for i in range(len(numbers)):
        numbers[i].sort()
        summ_of_minimums += numbers[i][0]
    return(summ_of_minimums)

def sum_of_minimums(n):
    return sum(min(a) for a in n)

def sum_of_minimums(numbers):
    result = []
    for counter, value in enumerate(numbers):
        num = min(numbers[counter])
        result.append(num)
    return sum(result)

def sum_of_minimums(numbers):
    min = 0
    
    for n in numbers:
        n.sort()
        min += n[0]
    return min

def sum_of_minimums(numbers):
    mins = []
    for lists in numbers:
        lists.sort()
        mins.append(lists[0])
    return sum(mins)
        


def sum_of_minimums(numbers):
    l = list()
    for x in numbers:
        x.sort()
        l.append(x[0])
    answer = sum(l)
    return answer

def sum_of_minimums(numbers):
    minimum = 0
    for i in range(len(numbers)):
        minimum +=min(numbers[i])
    return minimum

def sum_of_minimums(arr):
    mx = 0
    for i in range(len(arr)):
        mn = min(arr[i])
        mx += mn
    return mx

def sum_of_minimums(numbers):
    som = 0
    for element in numbers:
        som += min(element)
    return som

def sum_of_minimums(numbers):
    val = 0
    for i in numbers:
        val += min(i)
    return val

def sum_of_minimums(numbers):
    c = [min(c) for c in numbers]
    return sum(c)

def sum_of_minimums(numbers):
    ans = 0
    for arr in numbers:
        ans += min(arr)
    return ans



def sum_of_minimums(numbers):
    return sum(min(zs) for zs in numbers)

def sum_of_minimums(numbers):
    mns=[]
    for i in range(len(numbers)):
        mns.append(min(numbers[i]))
    return sum(mns)

def sum_of_minimums(numbers):
    accumulator = 0
    for eachlist in numbers:
        accumulator = accumulator + min(eachlist)
    return accumulator

def sum_of_minimums(numbers):
    return sum([min(group) for group in numbers])

def sum_of_minimums(numbers):
    x = []
    for i in numbers:
        x.append(min(i))
    return sum(x)

def sum_of_minimums(numbers):
    counter = 0
    for list in numbers:
        counter += min(list)
    return counter

sum_of_minimums = lambda numbers: sum(min(arr) for arr in numbers)

def sum_of_minimums(numbers):
    total = 0
    for value in range(len(numbers)):
        total += min(numbers[value])
    return total


def sum_of_minimums(n):
    sum=0
    for i in n:
        sum+=min(i)
    return sum

def sum_of_minimums(numbers):
    return sum(min(numbers[x]) for x in range(0,len(numbers)))

def sum_of_minimums(numbers):
    t=0
    for i in range(len(numbers)):
        x = min(numbers[i])
        t += x
    return t

def sum_of_minimums(numbers):
    return sum(sorted(numbers[i])[0] for i in range(len(numbers)))

def sum_of_minimums(numbers):
    return sum(min(lst_numbers) for lst_numbers in numbers)

def sum_of_minimums(numbers):
    Z=[]
    for i in numbers:
        Z.append(min(i))
        
    return(sum(Z))

def sum_of_minimums(numbers):
    z = []
    for x in numbers:
        z.append(min(x))
    return sum(z)

def sum_of_minimums(numbers):
#     for i in numbers:
#       x =  min(i)
      return sum(min(i) for i in numbers)

def sum_of_minimums(numbers):
    a = list()
    for i in numbers:
        a.append(min(i))
    return sum(a)

def sum_of_minimums(numbers):
    sum_num = 0
    for item in range(len(numbers)):
        sum_num += min(numbers[item])
    return sum_num

def sum_of_minimums (number):

    return sum([min(i) for i in number])

def sum_of_minimums(numbers):
    n=0
    for lista in numbers:
        n+=min(lista)
    return n


def sum_of_minimums(numbers):
    data = []
    for i in range(len(numbers)):
        data.append(min(numbers[i]))
    
    return (sum(data))

def sum_of_minimums(numbers):
  l = []
  for a in numbers:
    l.append(min(a))
  su = sum(l)
  return su

def sum_of_minimums(numbers):
    return sum(map(min, numbers))
        
print(sum_of_minimums([ [ 7,9,8,6,2 ], [6,3,5,4,3], [5,8,7,4,5] ]))

def sum_of_minimums(argumento):
    suma_min = []

    while argumento !=[]:
        var = argumento.pop(0)
        minvar = min(var)
        suma_min.append(minvar)

    suma=sum(suma_min)

    return suma



def sum_of_minimums(numbers):
    return sum(min(i for i in l) for l in numbers)


def sum_of_minimums(numbers):
    return sum(min(sorted(subarray)) for subarray in numbers)

def sum_of_minimums(numbers):
    a=[min(x) for x in numbers]
    return sum(a)
    #return min(numbers[0])+ min(numbers[1])+ min(numbers[2])
    pass

def sum_of_minimums(numbers):
    minimum_arr = []
    for arr in numbers:
        minimum_arr.append(min(arr))
    return sum(minimum_arr)

def sum_of_minimums(numbers):
    x = 0
    for lst in numbers:
        x += min(lst)
    return x

sum_of_minimums = lambda n: sum( min(a) for a in n )