/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package test;

import java.util.*;
/**
 *
 * @author peta
 */
public class Main {
  /** Zadani A priklad 1
   *
   * Takze nacist posloupnost cisel, kdyz je cislo zaporne tak rvat a nakonec napsat nejvetsi a druhy nejvetsi cislo.
   */
  public static void A1() {
    Scanner cin=new Scanner(System.in);
    System.out.println("Zadejte posloupnost kladnych cisel. Posloupnost ukoncite nulou.");
    int max1=0;
    int max2=0;
    int item=-1; // tak asi az sem je to zbytecny komentovat...
    while (item!=0) {
      System.out.println("Zadejte cislo:"); // vzdycky se slusne zeptame
      item=cin.nextInt();
      while (item<0) { // Kdyz by zadal zaporny cislo tak rveme
        System.out.println("Jen kladna cisla (nula pro konec):");
        item=cin.nextInt();
      }
      if (item>max1) { // kdyz se jedna o nejvetsi cislo,
        max2=max1; // posuneme dosud nejvetsi na druhe nejvetsi
        max1=item; // nejvetsi je nove
      } else if (item>max2) max2=item; // kdyz se jedna o druhe nejvetsi cislo, tak ho jen zmenime
    }
    System.out.println("Nejvetsi cisla jsou"+max1+","+max2);
  }
  /** Zadani B priklad 1
   *
   * Nacist pslpst cisel a zobrazovat meziprumer. pri nule skoncit,
   */
  public static void B1() {
    Scanner cin=new Scanner(System.in);
    System.out.println("Zadejte posloupnost cisel. Posloupnost ukoncite nulou.");
    double avg=0; // meziprumer
    int items=0; // pocet cisel zadanych
    do {
      System.out.println("Zadejte cislo");   
      int item=cin.nextInt();    
      if (item!=0) { // tady je duelzity jak se pocita prubeznej prumer
        avg=avg*items+item; // prumer = (stary prumer*pocet cisel+nove cislo)/novy pocet cisel
        items=items+1;
        avg=avg/items;
        System.out.println("Meziprumer je:"+avg); // vypiseme ho
      } else break; // jinak breakujeme cyklus
    } while (true);
    System.out.println("Vysledny prumer je:"+avg);
  }
  /** Zadani A priklad 2
   *
   * Tahle funkce vrati soucet toho ctverecku, hloubka ctverecku je jak moc je vnoreny. 0 je okrajovy ctverecek.
   *
   * !! Tenhle kod ma slozitost n**2, jde to udelat i jednoduseji radove kdyz to rozdelime na 4 forcykly, ja jsem
   * chtel ukazat tohle, protoze trik "zapocitam jen ty na hranach" je casto pouzivany. Oba dva postupy jsou za plny pocet bodu.
   */
  public static int addSquare(int depth, int[][] m) {
    int result=0;
    if (m.length-depth-1<depth) return -1; // kdyz je hloubka moc velika vratime -1
    for (int x=depth;x<m.length-depth;x++) {  // jinak jedeme forcyklem pres vsecny prvky co jsou na hranici ctverecku nebo v nem
      for (int y=depth;y<m.length-depth;y++) {
        if ((x==depth) || (y==depth) || (x==m.length-depth-1)  || (y==m.length-depth-1))
            result=result+m[x][y]; // a jen ty co jsou na hranici zapocitame
      }
    }
    return result;
  }
  /** Zadani A priklad 2
   *
   * Spusteni prikladu, definuje matici v kodu a pusti forcyklus na nai s hloubkou.
   */
  public static void A2() {
    int m[][]={{1,2,3,4,5},
               {5,6,7,1,5},
               {4,5,6,7,4},
               {4,5,2,6,7},
               {4,5,6,2,4}};
    for (int depth=0;depth<Math.ceil(m.length/2.0);depth++) { // hloubka jde od nuly do horni cele casti poloviny velikosti matice
      System.out.println("Soucet ctverce hloubky "+depth+" je "+addSquare(depth,m));
    }
  }
  /** Zadani B priklad 2
   *
   * Seradi row-ty radek v matici.
   */
  public static void orderRow(int row, int[][] m) {
    for (int i=1;i<m[row].length;i++) {
      for (int j=i;j>0;j--) {
        if (m[row][j]<m[row][j-1]) { // pouzivam insertion sort
          int x=m[row][j];
          m[row][j]=m[row][j-1];
          m[row][j-1]=x;
        }  else break;
      }
    }
  }
  /** Zadani B priklad 2
   *
   * Seradi col-ty sloupec v matici.
   */
  public static void orderCol(int col, int[][] m) {
    for (int i=1;i<m.length;i++) {
      for (int j=i;j>0;j--) {
        if (m[j][col]<m[j-1][col]) { // A zase byste meli poznat insertion sort
          int x=m[j][col];
          m[j][col]=m[j-1][col];
          m[j-1][col]=x;
        }  else break;
      }
    }
  }
  /** Zadani B priklad 2
   *
   * Tohle proste vypise matici...
   */
  public static void printMatrix(int [][] m) {
    for (int y=0;y<m.length;y++) {
      String line="";
      for (int x=0;x<m[y].length;x++) {
        line=line+" "+m[y][x];
      }
      System.out.println(line);
    }
  }
  /** Zadani B priklad 2
   *
   * Spusteci metoda, proste zase definuje matici (i obdelnikovou). a tu pak setridi
   * nejdriv po radcich a potom po sloupcich.
   */
  public static void B2() {
    int m[][]={{1,2,3,4,5,3},
               {5,6,7,1,5,5},
               {4,5,6,7,4,8},
               {4,5,2,6,7,1},
               {4,5,6,2,4,7}};
    for (int i=0;i<m.length;i++) orderRow(i,m);
    for (int i=0;i<m[0].length;i++) orderCol(i,m);
    printMatrix(m); // Nakonci upravenou matici vypise.
  }
  /**
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    // TODO code application logic here
    System.out.println("-------------------------------------------------------");
    System.out.println("Zadani A priklad 1");
    A1();
    System.out.println("-------------------------------------------------------");
    System.out.println("Zadani A priklad 2");
    A2();
    System.out.println("-------------------------------------------------------");
    System.out.println("Zadani B priklad 1");
    B1();
    System.out.println("-------------------------------------------------------");
    System.out.println("Zadani B priklad 2");
    B2();
  }

}