Programmieren lernen

/**
 * Transponieren einer Matrix (= Spielgung an der Diagonalen)
 * 
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class Transponieren {

    public Object[][] transponieren(Object[][] matrix) {
        int anzahlSpalten = getBreite(matrix);
        int anzahlZeilen  = getHoehe(matrix);
        Object[][] transponierte;
        transponierte = new Object[anzahlSpalten][anzahlZeilen];
        int zeile = 0; // Von oben nach unten im Original =
        // Von links nach rechts im Resultat;
        while (zeile < anzahlZeilen) {
            int spalte = 0;
            while (spalte < anzahlSpalten) {
                Object wert = getWert(matrix, spalte, zeile);
                transponierte[spalte][zeile] = wert;
                spalte = spalte + 1;
            }
            zeile = zeile + 1;
        }
        return transponierte;
    }

    public void printMatrix(Object[][] matrix) {
        int zeile = 0;

        while (zeile < getHoehe(matrix)) {
            int spalte = 0;
            while (spalte < getBreite(matrix)) {
                System.out.print(getWert(matrix, spalte, zeile));
                spalte = spalte + 1;
                if (spalte < getBreite(matrix)) {
                    System.out.print(", ");
                }
            }
            System.out.println();
            zeile = zeile + 1;
        }
    }

    int getHoehe(Object[][] matrix) {
        return matrix.length;
    }

    int getBreite(Object[][] matrix) {
        int breite = 0;
        int reihe = 0;
        while (reihe < getHoehe(matrix)) {
            Object[] zeile = matrix[reihe];
            if (zeile.length > breite) {
                breite = zeile.length;
            }
            reihe = reihe + 1;
        }
        return breite;
    }

    Object getWert(Object[][] matrix, int spalte, int zeile) {
        Object[] reihe = matrix[zeile];
        if (reihe.length > spalte) {
            return reihe[spalte];
        }
        return null;
    }

    // Tests
    public static void main(String[] args) {
        new Transponieren().testSixPack();
        new Transponieren().testUnvollstaendig();
    }

    public void testSixPack() {
        Object[][] m = { { 1, 2, 3 }, { 6, 8, 9 } };
        printMatrix(m);
        Object[][] transponierte = transponieren(m);
        printMatrix(transponierte);
    }

    public void testUnvollstaendig() {
        Object[][] m = { { 1, 2, 3 }, { 6, 8 }, { 33, 22, 1, 4 }, { 6, 5, 3 } };
        printMatrix(m);
        Object[][] transponierte = transponieren(m);
        printMatrix(transponierte);
    }
    
} // end of class Transponieren
                

def transponieren(a):
    c=[]
    for j in range(0,len(a[0])):
        b=[]
        for i in range(0,len(a)):
            b.append(a[i][j])
        c.append(b)
    
    return c


a = [[3,5],[4,2],[7,8]]    
aT = transponieren(a)
print(aT)
print(transponieren(aT))
                

Lösung von: Alex Groeg (Freies Lernen)

function transpose(matrix) {
  let t = [],   // [t]ransposed
      x, y;
  for (x = 0; x < matrix[0].length; x++) {
    t.push([]);
    for (y = 0; y < matrix.length; y++)
      t[x].push(matrix[y][x]);
  }
  return t;
}

let matrix = [ [3,5], [4,2], [7,8] ];
console.table(transpose(matrix));                            // lissalanda@gmx.at
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET 6.x | C# 10.x | VS-2022

List<List<int>> matrix = new() { new() { 3, 5 }, new() { 4, 2 }, new() { 7, 8 } };

var transposed = matrix.SelectMany(inner => inner.Select((item, index) => new { item, index })).GroupBy(i => i.index, i => i.item).Select(x => x.ToList());

transposed.ToList().ForEach(x => Console.WriteLine(string.Join(", ", x)));
// 3, 4, 7
// 5, 2, 8
                

Lösung von: Jens Kelm (@JKooP)