~~~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: EASY
Tags: Fundamentals

Data structures
Skill types: Data structures

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:
	return sum(map(min, numbers))


from typing import List

def sum_of_minimums(numbers: List[int]) -> int:
	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])


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):
	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):
	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):
	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):
	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):
	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):
	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(sorted(subarray)) for subarray in numbers))


def sum_of_minimums(numbers):
	a = [min(x) for x in numbers]
	return sum(a)
	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))