Massimi per riga/colonna, trasposizione e formattazione
Trovare in sicurezza i massimi per riga e colonna (anche con array irregolari) e costruire trasposte di matrici (rettangolari e irregolari). Esercitarsi nella stampa allineata.
Massimi per riga/colonna, trasposizione e formattazione è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 6. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 6 lezioni in totale.
Massimi per riga
Massimi per riga: calcoli il massimo di ogni riga scorrendone gli elementi una sola volta.
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);
}
}
Massimi per colonna
Massimi per colonna negli array irregolari: controlli la lunghezza di ogni riga prima di leggere la colonna 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);
}
}
Trasposta rettangolare
Trasposta (rettangolare): scambi righe e colonne quando tutte le righe hanno la stessa lunghezza.
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();
}
}
}
Trasposta irregolare
Trasposta (irregolare): crei le colonne come righe, dimensionando ciascuna in base alla lunghezza della riga più lunga e proteggendo gli accessi.
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();
}
}
}
Funzioni di supporto per la formattazione
Utilizzi funzioni di supporto per calcolare le larghezze delle colonne e stampare matrici allineate a scopo di confronto.
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);
}
}
Demo della trasposta
Esegua il codice: confronti le stampe allineate di una matrice rettangolare e della sua trasposta, quindi di una matrice irregolare, dei suoi massimi per colonna e della trasposta con riempimento.
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));
}
}
Verifica del massimo di colonna
Verifica rapida: per una matrice irregolare, come si calcola il massimo della colonna c?
Riepilogo e prossimo passo
Riepilogo: ha calcolato i massimi per riga e per colonna, ha trasposto matrici rettangolari e ha costruito una trasposta che gestisce gli array irregolari con riempimento. Ha anche formattato l'output allineato.
Domande Frequenti
La lezione «Massimi per riga/colonna, trasposizione e formattazione» è gratuita?
Sì — il testo completo di «Massimi per riga/colonna, trasposizione e formattazione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 6 lezioni in totale.
Cosa imparerò in «Massimi per riga/colonna, trasposizione e formattazione»?
Trovare in sicurezza i massimi per riga e colonna (anche con array irregolari) e costruire trasposte di matrici (rettangolari e irregolari). Esercitarsi nella stampa allineata. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 6.
Quanto tempo richiede la lezione «Massimi per riga/colonna, trasposizione e formattazione»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Basi degli array 2D e iterazione annidata
- Array irregolari e formattazione delle tabelle
- Massimi per riga/colonna, trasposizione e formattazione
- Mini-progetto 2D: registro dei voti
- Utility 2D come classe di supporto (refactoring)
- Pulizia e validazione dei dati 2D