# Pembahasan CS2 Alprog Kamis 20/02/2025
## Author: Misc/Dwi 

### Pendekatan:
Kita diperintahkan melakukan 3 operasi pada matriks yang diberikan:
- Cari Determinan
- Transpose matriks yang diberikan
- Kalikan transpose matriks dengan 1/det

### 1. Pertama kita akan melakukan pencarian determinan
Kita diberikan instruksi untuk melakukan pencarian determinan menggunakan aturan Sarrus, dan untuk sebuah matriks 3 x 3
Kita dapat mengambil tiap elemen dalam matriks kita dengan indeks posisinya dari 0 hingga 2, dan mengaplikasikan formula diatas. Kita dapat melakukannya dengan:

float finalDet;
void det(float matrix[3][3])
{
    //Ingat indeks elemen sebuah array mulai dari 0
    
    float det1 = matrix[0][0] * matrix[1][1] * matrix[2][2];
    //aei
    
    float det2 = matrix[0][1] * matrix[1][2] * matrix[2][0];
    //bfg
    
    float det3 = matrix[0][2] * matrix[1][0] * matrix[2][1];
    //cdh
    
    float det4 = matrix[2][0] * matrix[1][1] * matrix[0][2];
    //ceg
    
    float det5 = matrix[2][1] * matrix[1][2] * matrix[0][0];
    //afh
    
    float det6 = matrix[2][2] * matrix[1][0] * matrix[0][1];
    //bdi
    
    finalDet = det1 + det2 + det3 - det4 - det5 - det6; 
    //Determinan = aei + bfg + cdh - ceg - afh - bdi

    printf("Determinan matrixnya adalah: %.2f\n", finalDet);
}

### 2. Selanjutnya kita akan mencari transpose
untuk melakukan transpose kita harus memutar balikan baris menjadi kolom dan kolom menjadi baris, pada awalnya terdengar sederhana, tetapi sangat mudah untuk terkecoh jika tidak teliti

//Misalnya intuisi pertama kita mungkin untuk menulis sesuatu seperti ini
void transpose(float matrix[3][3]){
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            matrix[i][j] = matrix[j][i]
        }
    }
}

Tetapi kode ini jika kita bedah tidak akan menghasilkan matriks transpose yang benar karena:
kita melakukan perubahan langsung pada array yang masih sedang digunakan dalam iterasi. Perhatikan apa yang terjadi saat kita mengubah ```matrix[i][j]```:

Langkah pertama (i = 0, j = 1)

Data pada ```matrix[0][1]``` sekarang berubah menjadi nilai ```matrix[1][0]```.
Langkah kedua (i = 1, j = 0)

Nilai ```matrix[1][0]``` yang asli sudah hilang karena pada iterasi sebelumnya ```matrix[0][1]``` telah dimodifikasi.
Akibatnya:
Perubahan yang dilakukan akan mengacaukan data karena nilai yang sedang digunakan dalam perhitungan sudah diubah sebelum digunakan dalam iterasi lainnya.

Maka untuk melakukan transpose yang benar kita membutuhkan sebuah variabel sementara untuk menyimpan data asli pada matriks agar tidak terjadi transpose yang salah, maka code yang benarnya adalah:

void transpose(float matrix[3][3]){
    for (int i = 0; i < 3; i++){
        for (int j = i + 1; j < 3; j++){
            float temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
}

Dengan kode ini kita dapat menyimpan data matriks sebelum dilakukan pertukaran elemen sehingga tidak ada data yang tertimpa sebelum digunakan.

<b>Mengapa Metode Ini Berhasil?</b>

##### Metode ini Hanya Menukar Elemen di Atas Diagonal Utama:

Loop dalam hanya berjalan untuk ```j > i```, sehingga hanya elemen di atas diagonal utama yang ditukar dengan elemen di bawah diagonal utama.
Misalnya, ```matrix[0][1]``` ditukar dengan ```matrix[1][0]```, lalu ```matrix[0][2]``` dengan ```matrix[2][0]```, dan seterusnya.

##### Dan Metode ini Juga Mencegah Hilangnya Data Sebelum Selesai Digunakan

Dengan menggunakan variabel sementara temp, kita menyimpan nilai asli sebelum mengubahnya.
Jika kita langsung menimpa ```matrix[i][j]``` tanpa menyimpan nilai sebelumnya, maka nilai yang diperlukan untuk ```matrix[j][i]``` akan hilang.

### 3. Membagi dan Print

Terakhir kita perlu membagi transpose dengan determinan, lalu mengoutput hasil akhirnya ke terminal kita.

Sederhana saja dapat langsung melakukan hal tersebut dengan fungsi fungsi berikut:

//Bagi
void operasi(float matrix[3][3], float finalDet){
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            matrix[i][j] /= finalDet; //Andrew's implementation
        }
    }
}

//Print
void print(float matrix[3][3]){
    for (int i = 0; i < 3; i++){
        for (int j = 0; j < 3; j++){
            printf("%.1f ", matrix[i][j]); //Print tiap elemen kolom
        }
        printf("\n"); //Tambahkan baris
    }
}

Selesai, maka kode akhirnya akan terlihat seperti:

### Full code:

#include <stdio.h>

float finalDet; // Deklarasi global agar tidak memerlukan pointer

void det(float matrix[3][3]) {
    float det1 = matrix[0][0] * matrix[1][1] * matrix[2][2];
    float det2 = matrix[0][1] * matrix[1][2] * matrix[2][0];
    float det3 = matrix[0][2] * matrix[1][0] * matrix[2][1];
    float det4 = matrix[2][0] * matrix[1][1] * matrix[0][2];
    float det5 = matrix[2][1] * matrix[1][2] * matrix[0][0];
    float det6 = matrix[2][2] * matrix[1][0] * matrix[0][1];

    finalDet = det1 + det2 + det3 - det4 - det5 - det6;
    printf("Determinan matrixnya adalah: %.2f\n", finalDet);
}

void transpose(float matrix[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = i + 1; j < 3; j++) {
            float temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
}

void operasi(float matrix[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            matrix[i][j] /= finalDet;
        }
    }
}

void print(float matrix[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%.1f ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    float matrix[3][3] = {
        {2, 1, 1},
        {3, 2, 1},
        {1, 1, 2}
    };

    det(matrix);

    if (finalDet == 0) {
        printf("Determinan 0, matriks tidak dapat dibalik.\n");
        return 1;
    } 
    //Fungsi ini opsional karena matriks sudah diberikan di soal

    transpose(matrix);
    operasi(matrix);
    printf("Hasil akhir:\n");
    print(matrix);

    return 0;
}

## Terimakasih