Row/Column Maxima, Transpose & Formatting
Find row/column maxima safely (jagged-aware) and build matrix transposes (rectangular and jagged). Practice aligned printing.
Row/Column Maxima, Transpose & Formatting is a free Java Academy lesson on CoddyKit. This is lesson 3 of 6. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Java Academy learning path, and your progress syncs across the web and the CoddyKit app. The Java Academy course includes 6 lessons in total.
Row Maxima
Row maxima: compute the max of each row by scanning its elements once.
public class Main {
public static void main(String[] args) {
// Example jagged array
int[][] m = {
{1, 7, 3},
{4, 9, 2, 11},
{6}
};
int r = 1; // choose which row to check (row index 1 → {4, 9, 2, 11})
// Max of a single row r
int max = Integer.MIN_VALUE; // start with very small number
for (int c = 0; c < m[r].length; c = c + 1) {
if (m[r][c] > max) {
max = m[r][c]; // update if current value is larger
}
}
System.out.println("Max value in row " + r + " = " + max);
}
}
Column Maxima
Column maxima in jagged arrays: check each row's length before reading column c.
public class Main {
public static void main(String[] args) {
// Example jagged array (rows with different lengths)
int[][] m = {
{1, 7, 3},
{4, 9}, // shorter row (only 2 columns)
{6, 2, 11, 5} // longer row (4 columns)
};
int c = 2; // column index to check (3rd column)
// Max of column c across all rows
int colMax = Integer.MIN_VALUE;
for (int r = 0; r < m.length; r = r + 1) {
// Guard: only access if this row has column c
if (c < m[r].length) {
if (m[r][c] > colMax) {
colMax = m[r][c]; // update maximum
}
}
}
System.out.println("Max value in column " + c + " = " + colMax);
}
}
Transpose Rect
Transpose (rectangular): swap rows and columns when all rows have the same length.
public class Main {
public static void main(String[] args) {
// Example 2D rectangular matrix (3 rows × 2 columns)
int[][] m = {
{1, 2},
{3, 4},
{5, 6}
};
// Dimensions
int rows = m.length; // number of rows in m
int cols = m[0].length; // number of columns in m
// Transposed matrix (C × R)
int[][] t = new int[cols][rows];
// Fill transposed matrix
for (int r = 0; r < rows; r = r + 1) {
for (int c = 0; c < cols; c = c + 1) {
t[c][r] = m[r][c]; // swap row/column
}
}
// Print original matrix
System.out.println("Original matrix:");
for (int r = 0; r < rows; r++) {
for (int c = 0; c < cols; c++) {
System.out.print(m[r][c] + " ");
}
System.out.println();
}
// Print transposed matrix
System.out.println("Transposed matrix:");
for (int r = 0; r < t.length; r++) {
for (int c = 0; c < t[r].length; c++) {
System.out.print(t[r][c] + " ");
}
System.out.println();
}
}
}
Transpose Jagged
Transpose (jagged): create columns as rows, sizing each using the longest row length and guarding reads.
public class Main {
public static void main(String[] args) {
// Example jagged array (rows of different lengths)
int[][] m = {
{1, 2, 3},
{4, 5},
{6}
};
// 1) Find the maximum number of columns across all rows
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) {
if (m[r].length > maxCols) {
maxCols = m[r].length;
}
}
// 2) Create transpose: it will have maxCols rows
int[][] t = new int[maxCols][];
// 3) Fill the transposed matrix
for (int c = 0; c < maxCols; c = c + 1) {
// Each transposed row has as many elements as original rows
t[c] = new int[m.length];
for (int r = 0; r < m.length; r = r + 1) {
// If row is too short, pad with 0
t[c][r] = (c < m[r].length) ? m[r][c] : 0;
}
}
// Print original jagged array
System.out.println("Original jagged array:");
for (int r = 0; r < m.length; r++) {
for (int c = 0; c < m[r].length; c++) {
System.out.print(m[r][c] + " ");
}
System.out.println();
}
// Print transposed array
System.out.println("Jagged-safe transpose:");
for (int r = 0; r < t.length; r++) {
for (int c = 0; c < t[r].length; c++) {
System.out.print(t[r][c] + " ");
}
System.out.println();
}
}
}
Formatting Helpers
Use helpers to compute column widths and print aligned matrices for comparison.
public class Main {
// Compute per-column widths for a (possibly jagged) 2D int array.
// For each column index c, we find the longest string length among m[r][c] (for rows that have that column).
static int[] widths(int[][] m) {
// 1) Find the maximum number of columns across all rows
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) {
if (m[r].length > maxCols) maxCols = m[r].length;
}
// 2) Prepare width array (initialized to 0)
int[] w = new int[maxCols];
// 3) For each existing cell, compute the string length and keep the max per column
for (int r = 0; r < m.length; r = r + 1) {
for (int c = 0; c < m[r].length; c = c + 1) {
int len = Integer.toString(m[r][c]).length();
if (len > w[c]) w[c] = len;
}
}
// 4) Ensure each column has at least width 1
for (int c = 0; c < w.length; c = c + 1) {
if (w[c] < 1) w[c] = 1;
}
return w;
}
// Print a (possibly jagged) matrix so that each column is right-aligned using the widths[] computed above.
static void printAligned(int[][] m) {
int[] w = widths(m); // column widths
for (int r = 0; r < m.length; r = r + 1) {
String line = "";
for (int c = 0; c < m[r].length; c = c + 1) {
// Convert number to string
String s = Integer.toString(m[r][c]);
// Left-pad with spaces until it matches the target column width
while (s.length() < w[c]) s = " " + s;
// Append to the line; add a single space between columns (but not after the last one)
line = line + s + (c + 1 < m[r].length ? " " : "");
}
// Print the fully assembled row
System.out.println(line);
}
}
public static void main(String[] args) {
// Demo with a jagged matrix (different row lengths)
int[][] m = {
{1, 200, 3},
{45, 6},
{7, 89, 1000, 11}
};
System.out.println("Aligned output:");
printAligned(m);
}
}
Transpose Demo
Run it: Compare aligned prints of a rectangular matrix and its transpose, then a jagged matrix, its column maxima, and padded transpose.
public class Main {
// Compute column maxima (jagged-safe)
static int[] colMaxima(int[][] m) {
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[] max = new int[maxCols];
for (int c = 0; c < maxCols; c = c + 1) {
int best = Integer.MIN_VALUE;
boolean seen = false;
for (int r = 0; r < m.length; r = r + 1) {
if (c < m[r].length) {
if (!seen || m[r][c] > best) { best = m[r][c]; seen = true; }
}
}
max[c] = seen ? best : 0;
}
return max;
}
// Transpose rectangular
static int[][] transposeRect(int[][] m) {
int rows = m.length;
int cols = m[0].length;
int[][] t = new int[cols][rows];
for (int r = 0; r < rows; r = r + 1) {
for (int c = 0; c < cols; c = c + 1) t[c][r] = m[r][c];
}
return t;
}
// Jagged-safe transpose (pads missing with 0)
static int[][] transposeJagged(int[][] m) {
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[][] t = new int[maxCols][];
for (int c = 0; c < maxCols; c = c + 1) {
t[c] = new int[m.length];
for (int r = 0; r < m.length; r = r + 1) t[c][r] = (c < m[r].length) ? m[r][c] : 0;
}
return t;
}
// Helpers
static int[] widths(int[][] m) {
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[] w = new int[maxCols];
for (int r = 0; r < m.length; r = r + 1) {
for (int c = 0; c < m[r].length; c = c + 1) {
int len = Integer.toString(m[r][c]).length();
if (len > w[c]) w[c] = len;
}
}
for (int c = 0; c < w.length; c = c + 1) if (w[c] < 1) w[c] = 1;
return w;
}
static void printAligned(int[][] m) {
int[] w = widths(m);
for (int r = 0; r < m.length; r = r + 1) {
String line = "";
for (int c = 0; c < m[r].length; c = c + 1) {
String s = Integer.toString(m[r][c]);
while (s.length() < w[c]) s = " " + s;
line = line + s + (c + 1 < m[r].length ? " " : "");
}
System.out.println(line);
}
}
public static void main(String[] args) {
// Rectangular example for transpose
int[][] rect = {
{1, 2, 3},
{4, 5, 6}
};
// Jagged example for maxima and jagged transpose
int[][] jag = {
{9, 12, 7},
{5},
{8, 10}
};
System.out.println("rect:");
printAligned(rect);
System.out.println("transpose(rect):");
printAligned(transposeRect(rect));
System.out.println("jag (jagged):");
printAligned(jag);
int[] cm = colMaxima(jag);
System.out.print("col maxima: ");
for (int i = 0; i < cm.length; i = i + 1) System.out.print(cm[i] + (i + 1 < cm.length ? " " : ""));
System.out.println();
System.out.println("transpose(jag, padded):");
printAligned(transposeJagged(jag));
}
}
Column Max Check
Quick check: For a jagged matrix, how do you compute the maximum of column c?
Recap & Next
Recap: You computed row/column maxima, transposed rectangular matrices, and built a jagged-safe transpose with padding. You also formatted aligned output.
Learn Java with an AI tutor — free
Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.
- Courses
- 104
- Lessons
- 374
Frequently Asked Questions
Is the “Row/Column Maxima, Transpose & Formatting” lesson free?
Yes — the full text of “Row/Column Maxima, Transpose & Formatting” is free to read here on the web. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Java Academy course, upgrade to CoddyKit PRO. The Java Academy course includes 6 lessons in total.
What will I learn in “Row/Column Maxima, Transpose & Formatting”?
Find row/column maxima safely (jagged-aware) and build matrix transposes (rectangular and jagged). Practice aligned printing. You practise Java Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Java Academy?
No prior experience is required. Java Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 3 of 6.
How long does the “Row/Column Maxima, Transpose & Formatting” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Java Academy lesson?
Yes. Every Java Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- 2D Array Basics & Nested Iteration
- Jagged Arrays & Table Formatting
- Row/Column Maxima, Transpose & Formatting
- 2D Mini-Project: Gradebook
- 2D Utilities as a Helper Class (Refactor)
- 2D Data Cleaning & Validation