Update learn.md To replace CSR with CSC explanation

questions/67_implement-compressed-column-sparse-matrix-format-c/learn.md

@@ -1,48 +1,49 @@
+## Understanding the Compressed Column Sparse Matrix Format
 
-## Understanding the Compressed Row Sparse Matrix Format
-
-The Compressed Row Sparse (CSR) format is a data-efficient representation of sparse matrices, where most of the elements are zero. This format is particularly useful in large-scale scientific computing and machine learning applications, where memory efficiency is critical.
+The Compressed Column Sparse (CSC) format is a memory-efficient representation of sparse matrices, where most elements are zero. This format is especially useful in scientific computing, numerical simulations, and optimization problems where matrix operations often focus on columns.
 
 ### Concepts
 
-A sparse matrix is a matrix that contains a large number of zero elements. Storing such matrices in their full form can be inefficient, both in terms of memory and computational resources. The CSR format addresses this problem by storing only the non-zero elements and their positions in the matrix. In the CSR format, a matrix is represented by three one-dimensional arrays:
+A sparse matrix is one that contains a large number of zero elements. Storing such matrices in a standard two-dimensional format wastes memory and computation time. The CSC format solves this by storing only the non-zero elements and their positions.
+In the CSC format, a matrix is represented by three one-dimensional arrays:
 
-1) **Values array**: Contains all the non-zero elements of the matrix, stored row by row.  
-2) **Column indices array**: Stores the column index corresponding to each value in the values array.  
-3) **Row pointer array**: Stores the cumulative number of non-zero elements in each row, allowing quick access to each row's data. This means that it points to the position within the column indices array at which the row starts.
+1. **Values array**: Contains all the non-zero elements of the matrix, stored column by column.
+2. **Row indices array**: Stores the row index corresponding to each value in the values array.
+3. **Column pointer array**: Stores the cumulative number of non-zero elements in each column, allowing quick access to each column's data. It points to the position within the row indices array where the column starts.
 
 ### Structure
 
 Given a matrix:
 
 $$
 \begin{bmatrix}
-1 & 0 & 0 & 0 \\
-0 & 2 & 0 & 0 \\
-3 & 0 & 4 & 0 \\
-1 & 0 & 0 & 5
+0 & 0 & 3 & 0 \\
+1 & 0 & 0 & 4 \\
+0 & 2 & 0 & 0
 \end{bmatrix}
 $$
 
-The CSR representation would be:
+The CSC representation would be:
 
-1) **Values array**: [1, 2, 3, 4, 1, 5]  
-2) **Column indices array**: [0, 1, 0, 2, 0, 3]  
-3) **Row pointer array**: [0, 1, 2, 4, 6]
+1. **Values array**: \[1, 2, 3, 4]
+2. **Row indices array**: \[1, 2, 0, 1]
+3. **Column pointer array**: \[0, 1, 2, 3, 4]
 
 ### Explanation:
 
-1) The **values array** holds the non-zero elements in the matrix, in row-major order.
-2) The **column indices array** stores the corresponding column index of each non-zero element.
-3) The **row pointer array** keeps track of where each row starts in the values array. For example, row 1 starts at index 0, row 2 starts at index 1, row 3 starts at index 2, within the columns indices array, and so on.
+1. The **values array** contains the non-zero elements in column-major order.
+2. The **row indices array** stores the corresponding row index for each non-zero element.
+3. The **column pointer array** indicates where each column starts in the values array. For example, column 0 starts at index 0, column 1 starts at index 1, column 2 starts at index 2, and so on.
 
 ### Applications
 
-The CSR format is widely used in high-performance computing applications such as:
+The CSC format is widely used in:
+
+1. **Solving sparse linear systems** (especially in column-oriented algorithms)
+2. **Optimization problems** where column operations dominate
+3. **Graph algorithms** where adjacency matrices are processed by columns
+4. **Sparse matrix factorizations** (e.g., LU decomposition)
+
+The CSC format improves memory usage and computational efficiency by storing only the necessary non-zero elements and enabling fast access to column data.
 
-1) **Finite element analysis (FEA)**
-2) **Solving large sparse linear systems** (e.g., in numerical simulations)
-3) **Machine learning algorithms** (e.g., support vector machines with sparse input)
-4) **Graph-based algorithms** where adjacency matrices are often sparse
 
-The CSR format improves both memory efficiency and the speed of matrix operations by focusing only on non-zero elements.