def f_c_v1(M):
    arySum = M.sum(1)
    return M / arySum.reshape((M.shape[0], 1))

1. Compute the Row Sums:
   • arySum = M.sum(1) sums over axis 1 of the 2D array M.
   • Recall that in numpy, summing over axis 1 means summing across the columns for each row.
   • If M has shape $(n,m)$, M.sum(1) produces a 1D array of shape $(n,)$ where each entry is the sum of an entire row of M.
     • For instance, if row 0 has entries $[r_{0,0},r_{0,1},...,r_{0,m-1}]$, then M.sum(1)[0] is $\sum_jr_{0,j}$.
2. Reshape for Broadcasting:
   • arySum.reshape((M.shape[0], 1)) changes the shape of arySum from $(n,)$ to $(n,1)$.
   • This reshaping makes it compatible with the shape of M, which is $(n, m)$.
   • In particular, once arySum is of shape $(n,1)$, numpy broadcasting rules will align each row sum with all columns in that corresponding row when we perform the division.
3. Divide Element-Wise:
   • M / arySum.reshape((M.shape[0], 1)) divides each element of row $i$ of M by the $i$-th row sum (stored in arySum[i]).
   • Because each row is divided by its sum, the resulting array has rows that each sum to 1.
   • This operation returns a new array, leaving M unmodified.
4. Return the Normalised Matrix:
   • The function returns the 2D array where each row has been normalised to sum up to 1.

Example Illustration

Suppose you have the following matrix:

1.0 3.0 1.0
2.0 4.0 4.0
6.0 3.0 6.0
4.0 7.0 9.0

1. Row sums:

   • First row: $1.0+3.0+1.0=5.0$
   • Second row: $2.0+4.0+4.0=10.0$
   • Third row: $6.0+3.0+6.0=15.0$
   • Fourth row: $4.0+7.0+9.0=20.0$
   • Hence, arySum is the 1D array [5.0, 10.0, 15.0, 20.0].

2. Reshaping:

   • arySum.reshaping((4, 1)) becomes:

     [
     	[5.0],
     	[10.0],
     	[15.0],
     	[20.0]
     ]
     

     This matches the number of rows in M, but has a single column.

3. Normalisation:

   • The division M / (reshaped arySum) transforms each element $M[i,j]$ into $\frac{M[i,j]}{\text{arySum}[i]}$.
   • The outcome is a new matrix where each row sums to exactly 1.0.

Why This Version is Shorter

• No Explicit Loops: Instead of manually accumulating row sums, the built-in sum function is used with axis = 1.
• Broadcasting: By reshaping the row sums, each row division is automatically performed element-by-element without writing nested loops.
• One-Liner Return: The row sums are computed, reshaped, and used in a single expression to normalise M.