JAVA prohození matice podle vedlejší diagonály

Můžu se zeptat, co přesně má znamenat

kdy budou prohozené prvky podle hlavní/vedlejší diagonály

?

Prvky v řádcích, ve sloupcích, všechny? Ta první metoda je klasický výpis, ta druhá taky (BTW proč tam máš dvakrát tu samou metodu?? Vždyt přeci vygeneruješ matici, na tu zavolas vypis, pak ji tou metodou prohodPole nejak modifikujes a pak na tu modifikovanou staci zavolat ten samej vypis) a ta třetí na to prohazování (co vypadá jako nekompletní bubblesort) neudělá ani jedno z toho.

proč tam máš dvakrát tu samou metodu??

To by mi zajimalo jakym zpusobem si pri tom poradi java překladač, jestli je hloupej a nebo jestli to vykydli či udělá inline call a tudíš to bude jedno.

Myslim ze todle nijak osetřeny neni a prostě to bude překladat presne tak jak to je napsany, celej kod výše se da sbouchnout na polovinu. Zhruba takhle:

import java.util.Random;

public class Program {
    Random rd = new Random();
    int pole[][] = new int[5][5];

    void vygenerujPole() {
        for (int i = 0; i < pole.length; i++) {
            for (int j = 0; j < pole.length; j++) {
                pole[i][j] = rd.nextInt(11); //generuje jen od 0 do 10
              //pole[i][j] = -100 + rd.nextInt(201); //generovani v intervalu <-100,100>
              //pole[i][j] = min + generator(max - min +1);
            }
        }
    }
    
    void vypisPole(){
	for (int i = 0; i < pole.length; i++){
	    for (int prvek: pole[i]) System.out.printf("% 5d", prvek);//for-each cyklus
            //vypsani každeho řadku jako pole(matice je pole polí -> každý řádek je pole)
	    System.out.println(""); //odřadkovani za každym řadkem matice
	}
	System.out.println(""); //odřadkovani za matici
    }

    void prohoditPole() {
        for (int i = 0; i < pole.length; i++) {
            for (int j = i; j < pole.length; j++) {
                int pom = pole[i][j];
                pole[i][j] = pole[j][i];
                pole[j][i] = pom;
            }
        }
    }

    public static void main(String[] args) {
	Program matice = new Program();
	
        matice.vygenerujPole();
	matice.vypisPole();
	
	System.out.println("Prohození podle hlavní diagonály");
		
	matice.prohoditPole();
	matice.vypisPole();
    }
}

BTW Nic to ale neměni na tom, že ta metoda prohodPole() tak, jak je napsana tazatelem, v podstate nic nedela.

Neměl bys prosím algoritmus na to samý akorát podle vedlejší diagonály? Díky moc

nallim pisal ze "Už to mám, děkuji. :)"
Ty si zas kto? Preco by sme sem mali davat riesenia uplne primitivnych domacich uloh? Z toho co som pisal vyssie to uz musis mat davno hotove.

domácí úkol nebo by to mohla být ještě bakalářka na VŠE

to asi nie ptz nechapem prakticky vyznam takeho prehadzovania prvkov "podla diagonaly" takze to skor bude len nejake cvicenie na domacu ulohu (a ano neni uplne jasne ze co sa ma vlastne prehadzovat, ale zrejme sa mysli zrkadlenie celej matice podla diagonaly, tak to aspon chapem ja tu "ulohu").

Ak myslis prohozeni prvku nad HD/VD za prvky pod HD/VD tak se shodnem, ted me to taky napadlo.

Ano přesně tak to je, sice je transponovaná matice, ale když se kouknete na prvky nad hl. diagonálou tak po provedení algoritmu jsou pod hl. diagonálou a naopak. Chtěl bych totéž pro vedlejší diagonálu. Když je to pro Vás tak jednoduché ocenil bych kdyby sem někdo napsal ten algoritmus(max. 5 řádků podle mě). Mám to na zkoušku a bohužel už jsem z toho tak blbej že to nevymyslim. Děkuji

Co je nepochopitelne na

si to predsa nakresli na papier a uvidis jak sa to robi. Ked to vies urobit rukou tak to vies aj naprogramovat bez toho aby si sa niekoho pytal.
Zistis ze chces [0,0] vymenit za [velkost,velkost], [1,1] za [velkost-1,velkost-1], apod. Toto som ti uz nemal pisat, mas vlastny rozum.

je v tom mala chyba a schavlne nenapisem v com, to by si mal vidiet sam. Ked to nezvladnes tak by si tu skusku urobit nemal, vo vlastnom zaujme :)

To jsem zase narazil na lidi ochotný

Viac ochotny byt clovek nemoze. Napisat kod neni ochota ptz potom zostanes blby, a to ochotny clovek nechce :)

chjo, tak zostan blby, mne je to fuk

int pom = pole[i][j];
pole[i][j] = pole[pole.length-1-i][pole.length-1-j];
pole[pole.length-1-i][pole.length-1-j] = pom;

dufam ze aspon tusis ze kam to mas dat

a nie hovadina (nechcelo sa mi to kreslit si) takto by to bmalo byt (si to preistotu over na papieri, mne sa nechce)

int pom = pole[i][j];
pole[i][j] = pole[pole.length-1-j][pole.length-1-i];
pole[pole.length-1-j][pole.length-1-i] = pom;

Nechci ti do toh kecat ale jaksi to nefunguje

void transponujPodleVD() {
    for (int j = 0; j < pole.length; j++) {
        for (int i = 0; i < pole.length-j; i++) {
            int pom = pole[i][j];
            pole[i][j] = pole[pole.length-1-j][pole.length-1-i];
            pole[pole.length-1-j][pole.length-1-i] = pom;
        }
    }  
}

Edit:Nechci ti do toho kecat, ale kdyz uz si od MM.. dostal zdarma tu vymenu, tak si mohl samostatne vypotit ten index, do ktereho muzes tu matici prochazet. Jak uz bylo psano, staci si to napsat na papir.

Edit2: MM.., proc me pri cteni vaseho nicku vzdycky napadne MM..Tank?
Edit3: Case Solved -> pivni_MM_Tank

MM ne Tank ale jako Mnichov- MM.. a Tank jsou jiní lidé - tenhle nemá bžilion cm ani bžilion kg jako Tank

MM je skratka mena a 2bodky su tam preto lebo min nick je 4znaky :) MM tank je typ tanku z nejakej z hry. Uznavam ze je to matuce :)

jaksi na tom nefunguje co konkretne? Ze ty tam pises pismeno l namiesto cislice 1? Copy paste vas tiez nenaucili. Vymen skolu.

Neřeš to, ty seš nejchytřejší ja sem debil

ja som nikde nenapisal ze si debil, ale ze ked sa nebudes snazit to pochopit ale budes len opisovat tak sa nic nenaucis (="zostanes blby"). Musis sa trochu snazit to pochopit, a to sa robi najlepsie tak, ze na to prides sam. Uz to funguje?

Ale já jsem se snažil, na HL. diagonalu jsme přišel, a spoustu jinejch veci proste tohle me netrklo no

To, co tu máš má jednu "malou" vadu na kráse, a to sice tu, že to bude fungovat jen pro čtvercové matice...

definuj "diagonalu" na obdlznikovej matici.

Šlo mi hlavně o ty metody pro výpis...

http://cs.wikipedia.org/wiki/Matice#Diagon.C3.A1la _matice
Nikde nevidím, že by musela být čtvercová...

No definuj mi diagonalu obdlznikovej matice. To akoze bude koncit niekde na hrane a nie v rohu? To potom neni diagonala. Je logicke ze diagonalu ma len stvorcova matica.

Diagonála matice A, je tvořena prvky A[i,j], kde i=j...

no tak by u obdlznika koncila na hrane, to je diagonala jak svina.

jaj aha metody pro vypis, no metody pro vypis su nahovno to som videl hned ale to neriesim ked to netrapi autora :) Ano metody pre vypis nie su (vseobecne) korektne

Tak jenom pro jistotu:

    void vypsatPole1() {
        for (int i = 0; i < pole.length; i++) {
            for (int j = 0; j < pole[i].length; j++) {
                System.out.printf("% 5d", pole[i][j]);
                if (j == (a - 1)) {
                    System.out.println("");
                }
            }
        }
    }

to odřádkování je epický no.

Náhodou tušil by někdo jak prohodit prvky pod hl. diagonálou mezi 2 maticema? prvky pod hl. diagonálou jsou i=1 až do poctuRadku a sloupce jsou i=0 až do i-1, akorát netuším jak udělat tu výměnu. Děkuji za krátký návod jak to udělat

int pom = pole1[i][j];
pole1[i][j] = pole2[i][j];
pole2[i][j] = pom;

Měl jsem udělat řazení matice podle posledního řádku. Tedy že největší prvek v posl. řádku bude první, a takhle sestupně nebo vzestupně. Udělal jsem to takhle, nešlo by to nějak jednosušejc?
public void serad(boolean vzestupne, int rozmer) {

int pocet = ((rozmer * rozmer) - rozmer) / 2;
int[] arrNad = new int[pocet];
int[] arrPod = new int[pocet];
int pNad = 0, pPod = 0;

for(int x = 0; x < rozmer; x++) {
for(int y = 0; y < rozmer; y++) {
if (y > x) {
arrNad[pNad++] = matice[x][y];
} else if (x > y) {
arrPod[pPod++] = matice[x][y];
}
}
}

sort(arrNad, vzestupne);
sort(arrPod, !vzestupne);

pNad = 0; pPod = 0;
for(int x = 0; x < rozmer; x++) {
for(int y = 0; y < rozmer; y++) {
if (y > x) {
matice[x][y] = arrNad[pNad++];
} else if (x > y) {
matice[x][y] = arrPod[pPod++];
}
}
}

}

private void sort(int[] array, boolean vzestupne) {
//TODO nějaká implementace sortingu

Arrays.sort(array);
if (!vzestupne) {
for (int left = 0, right = array.length - 1; left < right; left++, right--) {
int temp = array[left];
array[left] = array[right];
array[right] = temp;
}
}
}