0Pricing
Java Academy · Lesson

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 — 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, one of 6 lessons in the course, and your progress syncs across the web and the CoddyKit app.

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.

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, and the Java Academy course includes 6 lessons in total. 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.

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; this is — lesson 3 of 6, so you can start here or from the beginning and move at your own pace.

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

  1. 2D Array Basics & Nested Iteration
  2. Jagged Arrays & Table Formatting
  3. Row/Column Maxima, Transpose & Formatting
  4. 2D Mini-Project: Gradebook
  5. 2D Utilities as a Helper Class (Refactor)
  6. 2D Data Cleaning & Validation
← Back to Java Academy