Maxvärden per rad/kolumn, transponering och formatering
Hitta maxvärden per rad och kolumn på ett säkert sätt (med stöd för ojämna arrayer) och skapa matristransponeringar (rektangulära och ojämna). Öva på justerad utskrift.
Maxvärden per rad/kolumn, transponering och formatering är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 6. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 6 lektioner.
Radmaxima
Radmaxima: beräkna maximumvärdet för varje rad genom att gå igenom dess element en gång.
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);
}
}
Kolumnmaxima
Kolumnmaxima i ojämna arrayer: kontrollera längden på varje rad innan Ni läser kolumn 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);
}
}
Transponera rektangulär matris
Transponering (rektangulär): byt plats på rader och kolumner när alla rader har samma längd.
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();
}
}
}
Transponera ojämn matris
Transponering (ojämn): skapa kolumner som rader och bestäm storleken för varje rad utifrån den längsta raden, med skydd vid läsning.
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();
}
}
}
Formateringshjälpare
Använd hjälpfunktioner för att beräkna kolumnbredder och skriva ut justerade matriser för jämförelse.
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);
}
}
Transponeringsdemo
Kör det: Jämför justerade utskrifter av en rektangulär matris och dess transponering, och sedan en ojämn matris, dess kolumnmaxima och en utfylld transponering.
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));
}
}
Kontroll av kolumnmaximum
Snabbkontroll: Hur beräknar Ni maximumvärdet för kolumn c i en ojämn matris?
Sammanfattning och nästa steg
Sammanfattning: Ni har beräknat rad- och kolumnmaxima, transponerat rektangulära matriser och byggt en transponering som hanterar ojämna matriser med utfyllnad. Ni har också formaterat justerade utskrifter.
Lär dig Java med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 104
- Lektioner
- 374
Vanliga frågor
Är lektionen ”Maxvärden per rad/kolumn, transponering och formatering” gratis?
Ja – hela texten till ”Maxvärden per rad/kolumn, transponering och formatering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 6 lektioner.
Vad lär jag mig i ”Maxvärden per rad/kolumn, transponering och formatering”?
Hitta maxvärden per rad och kolumn på ett säkert sätt (med stöd för ojämna arrayer) och skapa matristransponeringar (rektangulära och ojämna). Öva på justerad utskrift. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Java Academy?
Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 6.
Hur lång tid tar lektionen ”Maxvärden per rad/kolumn, transponering och formatering”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Java Academy-lektionen?
Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Grunderna i 2D-arrayer och nästlad iteration
- Ojämna arrayer och tabellformatering
- Maxvärden per rad/kolumn, transponering och formatering
- 2D-miniprojekt: betygsbok
- 2D-verktyg som hjälparklass (refaktorering)
- Rensning och validering av 2D-data