A két kecskeméti vereség után már az is megfordult a fejemben, hogy nem a Loki lesz a bajnok... de itt az aktuális alternatív tabella, aminek félreérthetetlen az üzenete: a DVSC a Monicomp Liga jelen pillanatban is egyik legerősebb csapata, legalábbis az alternatív tabella szerint. De egy szám többet mond ezer szónál, így lássuk hát!

Íme egy feladat csak a labdarúgás és a programozás szerelmeseinek: tartsd karban a Wikipédia alternatív tabella szócikkét! A magyar NB1 őszi idényének végéig ezt magam tettem, sőt sok más bajnokságra is kiszámoltam erre a blogra. Most elvégzem a számítást, a bemutatott eredményeket úgy használd, hogy saját C kódodat addig gyúrd, amíg ezt nem kapod, amit én a Java progimmal (egyébként ezen a szinten pár szintaktikai különbség lesz csak, illetve nem a printf ír ki, hanem a System osztály out tagjának println függvénye, mindegy... illetve esetleg még az, hogy a Java tömb már öntudatéra ébredt: tudja a saját méretét). Hasznodra lesz közben azért, amit tanultál a PR-es bevezető labor kapcsán. Ha kérek valamit adok is alapon:

• 6 trófea annak, aki először megírja/átírja C-be (és az itteni adatokat produkálja)
• további 1 trófea hetenként (ugyanannak persze), ha frissíti is az említett szócikket közben (ez max. 8 trófea május 1-ig, ugye, de mindenesetre maximáljuk 6-ban)

Magam kicsit máshogy jártam el - AspectJ-vel dolgozva - de valamit hagyjunk a Prog2-re is, ezért az alábbi metódust javaslom: nézd meg a jelenlegi állást, majd hetente frissítsd az ez alapján karbantartott  mátrixot, ami így a számításod "bemenetét" képezze. Lássuk!

A feladatot két lépésben oldjuk meg. Először elkészítjük a 2. előadásban és a PR-es posztban is bemutatott "L" mátrixot. Ezt a Wiki2Matrix osztállyal oldjuk meg, s ezt a kiprintelt mátrixot betesszük forrásban az AlternativTabella osztályba, aki majd nyomja a PR-t, de nézd csak meg a forrásokat és világos lesz, hogy két egyszerűre bontott lépésről van szó, ami nem mutat túl a 2. labor mélységén (egyben is mutathatnám, de most nem téma sem az OO, sem a tervezési minta).

A Monicomp Liga

Ha nem követted magad a bajnokságot, akkor nézd meg a kereszttáblázatot! Ezt gépeld be  Wiki2Matrix kereszt nevű 2D tömbjébe az alábbiak szerint:

• üres=0
• zöld=1
• sárga=2
• piros=3

 Most ezt kaptam:

     int[][] kereszt = {
      {0, 0, 0, 1, 0, 3, 2, 3, 3, 2, 0, 0, 0, 2, 2, 3},
      {3, 0, 2, 1, 3, 2, 0, 3, 3, 3, 0, 0, 0, 0, 0, 1},    
      ...
      .
      .
      {0, 0, 1, 0, 1, 0, 3, 1, 1, 0, 0, 1, 2, 1, 3, 0}
    };

(Az első oszlop 2 sorának 3-as jegye azt mondja, hogy a megfelelő meccsen: a Honvéd otthonában a Siófok győzött.)

Ezzel a Wiki2Matrix osztályt lefordítva/lefuttatva:

javac Wiki2Matrix.java
java Wiki2Matrix

kinyomja a linkmátrixot, amit mutatok, ha kattintasz a tovább linkre, mert csúnya lesz...

{0.0, 0.08333333333333333, 0.0, 0.1111111111111111, 0.14285714285714285, ... 0.0625, ... 0.0, 0.0, }amit be kell tenned a AlternativTabella osztályba, az  double[][] L = {}; kapcsos karmai közé.

Wiki2Matrix.java

// Programozó Páternoszter
// Bátfai Norbert, nbatfai@gmail.com
//
// http://progpater.blog.hu/2011/03/11/alternativ_tabella
// lásd még az alábbiakat
// elmélet: http://nehogy.fw.hu/wp-content/uploads/Prog1_2.pdf
// labor: http://progpater.blog.hu/2011/02/13/bearazzuk_a_masodik_labort

public class Wiki2Matrix {

  public static void main(String[] args) {

    int[][] kereszt = {
      {0, 0, 0, 1, 0, 3, 2, 3, 3, 2, 0, 0, 0, 2, 2, 3},
      {3, 0, 2, 1, 3, 2, 0, 3, 3, 3, 0, 0, 0, 0, 0, 1},
      {1, 1, 0, 0, 3, 1, 3, 0, 0, 0, 3, 1, 1, 0, 2, 0},
      {0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 2, 1, 1},
      {3, 3, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0},
      {1, 0, 3, 1, 0, 0, 0, 1, 3, 2, 0, 0, 0, 1, 2, 3},
      {0, 2, 0, 0, 0, 1, 0, 1, 1, 0, 3, 0, 1, 3, 3, 1},
      {0, 0, 1, 1, 3, 0, 0, 0, 0, 1, 3, 1, 1, 1, 3, 0},
      {0, 0, 1, 2, 3, 0, 0, 1, 0, 0, 0, 2, 1, 1, 3, 1},
      {0, 1, 1, 2, 0, 0, 3, 1, 1, 0, 0, 0, 0, 1, 3, 3},
      {2, 3, 0, 2, 1, 1, 0, 0, 1, 2, 0, 1, 0, 0, 0, 2},
      {3, 3, 0, 0, 0, 3, 3, 0, 2, 1, 1, 0, 2, 0, 0, 0},
      {1, 2, 0, 1, 0, 2, 1, 0, 0, 1, 3, 1, 0, 0, 0, 2},
      {2, 1, 2, 0, 1, 2, 1, 0, 0, 0, 3, 1, 1, 0, 0, 0},
      {1, 3, 1, 0, 2, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0},
      {0, 0, 1, 0, 1, 0, 3, 1, 1, 0, 0, 1, 2, 1, 3, 0}
    };

    int[][] pontotSzerez = new int[kereszt.length][kereszt.length];

    for (int i = 0; i < pontotSzerez.length; ++i) {
      for (int j = 0; j < pontotSzerez[i].length; ++j) {
        pontotSzerez[i][j] = 0;
      }
    }

    for (int i = 0; i < pontotSzerez.length; ++i) {
      for (int j = 0; j < pontotSzerez[i].length; ++j) {

        if (kereszt[i][j] == 1) { // zφld

          ++pontotSzerez[i][j];

        } else if (kereszt[i][j] == 2) { // sαrga

          ++pontotSzerez[i][j];
          ++pontotSzerez[j][i];

        } else if (kereszt[i][j] == 3) { // piros

          ++pontotSzerez[j][i];

        } else if (kereszt[i][j] == 0) { // όres

          ;

        } else {
          System.out.println("Luke, zavart ιrzek az erυben...");
        }

      }
    }
 
    System.out.println("A x ontot-szerez y-tσl mαtrix");

    nyom(pontotSzerez);

    System.out.println("\nSor ιs oszlop φsszegekkel");

    nyom2(pontotSzerez);

    int oszlopOsszeg[] = new int[pontotSzerez.length];

    for (int i = 0; i < pontotSzerez.length; ++i) {

      int o = 0;
      for (int j = 0; j < pontotSzerez[i].length; ++j) {
        o += pontotSzerez[j][i];
      }
      oszlopOsszeg[i] = o;
    }

    System.out.println("\nA \"link\" mαtrix");

    nyom3(pontotSzerez, oszlopOsszeg);

  }

  public static void nyom(int[][] k) {
    for (int i = 0; i < k.length; ++i) {
      System.out.println();
      for (int j = 0; j < k[i].length; ++j) {
        System.out.print(k[i][j] + ", ");
      }
    }
  }

  public static void nyom2(int[][] k) {

    for (int i = 0; i < k.length; ++i) {
      System.out.println();
      int o = 0;
      for (int j = 0; j < k[i].length; ++j) {
        System.out.print(k[i][j] + ", ");
        o += k[i][j];
      }
      System.out.print("  " + o);
    }

    System.out.println();
    System.out.println();

    for (int i = 0; i < k.length; ++i) {

      int o = 0;
      for (int j = 0; j < k[i].length; ++j) {
        o += k[j][i];
      }
      System.out.print(o + " ");
    }

  }

  public static void nyom3(int[][] k, int[] oszlopOsszeg) {
    for (int i = 0; i < k.length; ++i) {
      System.out.println();
      System.out.print("{");
      for (int j = 0; j < k[i].length; ++j) {

        if (oszlopOsszeg[j] != 0.0) {
          System.out.print(k[i][j] * (1.0 / oszlopOsszeg[j]) + ", ");
        } else {
          System.out.print(k[i][j] + ", ");
        }

      }
      System.out.print("},");

    }
  }
}

AlternativTabella.java 

// Programozó Páternoszter
// Bátfai Norbert, nbatfai@gmail.com
//
// http://progpater.blog.hu/2011/03/11/alternativ_tabella
// lásd még az alábbiakat
// elmélet: http://nehogy.fw.hu/wp-content/uploads/Prog1_2.pdf
// labor: http://progpater.blog.hu/2011/02/13/bearazzuk_a_masodik_labort

public class AlternativTabella {

  public static void main(String[] args) {

    double[][] L = {
      {0.0, 0.08333333333333333, 0.0, 0.1111111111111111, 0.14285714285714285, 0.0, 0.1111111111111111, 0.0, 0.0, 0.08333333333333333, 0.1111111111111111, 0.0625, 0.0, 0.16666666666666666, 0.16666666666666666, 0.0,},
      {0.0, 0.0, 0.08333333333333333, 0.1111111111111111, 0.14285714285714285, 0.08333333333333333, 0.1111111111111111, 0.0, 0.0, 0.0, 0.1111111111111111, 0.0625, 0.07692307692307693, 0.0, 0.16666666666666666, 0.1111111111111111,},
      ...
      .
      .
      {0.07142857142857142, 0.0, 0.08333333333333333, 0.0, 0.14285714285714285, 0.08333333333333333, 0.0, 0.1, 0.1, 0.08333333333333333, 0.1111111111111111, 0.0625, 0.15384615384615385, 0.08333333333333333, 0.0, 0.0}
    };

    // az eredeti tabella sorrendje, 2011.03.11
    String[] csapatNevE = {
      "Videoton",
      "Ferencvαros",
      "Paks",
      "Debreceni VSC",
      "Zalaegerszegi TE",
      "Kaposvαri Rαkσczi",
      "Lombard Pαpa",
      "Kecskemιti TE",
      "Ϊjpest",
      "Gyυri ETO",
      "Budapest Honvιd",
      "MTK Budapest",
      "Vasas",
      "Szombathelyi Haladαs",
      "BFC Siσfok",
      "Szolnoki MΑV"
    };
    // az eredeti tabella pontjai, 2011.03.11
    int[] ep = {
      40,
      34,
      31,
      31,
      30,
      29,
      27,
      24,
      23,
      23,
      22,
      22,
      21,
      20,
      18,
      9
    };

    // az L mαtrix kιszνtιsekori sorrend (a blogra kettιbontottban ez a Wikis keresttαbla), 2011.03.11
    String[] csapatNevL = {
      "BFC Siσfok",
      "Budapest Honvιd",
      "Vasas",
      "Debreceni VSC",
      "Ferencvαros",
      "Gyυri ETO",
      "Kaposvαri Rαkσczi",
      "Kecskemιti TE",
      "Lombard Pαpa",
      "MTK Budapest",
      "Paksi FC",
      "Szolnoki MΑV FC",
      "Szombathelyi Haladαs",
      "Ϊjpest",
      "Videoton",
      "Zalaegerszegi TE"
    };

    double[] hv = new double[L.length];
    double[] h = new double[L.length];

    for (int i = 0; i < hv.length; ++i) {
      hv[i] = 1.0 / L.length;
      h[i] = 0.0;
    }

    double reginorma = 0.0, regiosszeg = 0.0;

    boolean amig = true;
    while (amig) {

      for (int i = 0; i < L.length; ++i) {
        for (int j = 0; j < L[i].length; ++j) {
          h[i] += L[i][j] * hv[j];
        }
      }

      // kicsit elegánsabban volt a laboron:
      // http://progpater.blog.hu/2011/02/13/bearazzuk_a_masodik_labort
      double osszeg = 0.0;
      for (int i = 0; i < h.length; ++i) {
        osszeg += (hv[i] - h[i]) * (hv[i] - h[i]);
      }

      System.out.println("iterαciσ...");

      double norma = Math.sqrt(osszeg);
      System.out.println("norma = " + norma);

      if (norma < .000000000001) {
        amig = false;

        System.out.println("+++");
        double osszegEll = 0.0;
        for (int i = 0; i < h.length; ++i) {

          osszegEll += h[i];
          System.out.println(h[i]);

        }
        System.out.println("φsszeg ell. = " + osszegEll);
        System.out.println("+++");

      }

      //double d = 0.98;
      double d = 0.87;
      //double d = 0.7;

      osszeg = 0.0;
      for (int i = 0; i < h.length; ++i) {

        //hv[i] = h[i];
        hv[i] = d * h[i] + (1.0 - d) / L.length;

        osszeg += hv[i];
        h[i] = 0.0;
      }

      System.out.println("φsszeg = " + osszeg);

      if (osszeg == regiosszeg && norma == reginorma) {
        amig = false;

        System.out.println("***");
        for (int i = 0; i < h.length; ++i) {
          System.out.println(hv[i]);
        }

        System.out.println("****");

        rendezCsapatok(csapatNevL, hv, csapatNevE, ep);

      }
      reginorma = norma;
      regiosszeg = osszeg;

    } // while
  }

  public static void rendezCsapatok(String[] s, double h[], String[] e, int ep[]) {

    System.out.println("\nCsapatok rendezve:\n");

    int csapatNevekMeret = h.length;

    Csapat csapatok[] = new Csapat[csapatNevekMeret];

    for (int i = 0; i < csapatNevekMeret; i++) {
      csapatok[i] = new Csapat(s[i], h[i]);
    }

    java.util.List<Csapat> rendezettCsapatok = java.util.Arrays.asList(csapatok);
    java.util.Collections.sort(rendezettCsapatok);
    java.util.Collections.reverse(rendezettCsapatok);
    java.util.Iterator iterv = rendezettCsapatok.iterator();
    int ii = 0;
    while (iterv.hasNext()) {
      Csapat csapat = (Csapat) iterv.next();

      String ds = Double.toString(csapat.ertek);
      int idx = ds.indexOf(".");
      StringBuffer sb = new StringBuffer();
      sb = sb.delete(0, sb.length());
      sb.append(ds.substring(0, idx + 5));
      String e4 = sb.toString();
System.out.println("|-");
      System.out.println("| " + e[ii]);
      System.out.println("| " + ep[ii]);
      System.out.println("| " + csapat.nev);
      System.out.println("| " + e4);

      ++ii;
    }
    System.out.println("|-");

  }
}

class Csapat implements Comparable<Csapat> {

  protected String nev;
  protected double ertek;

  public Csapat(String nev, double ertek) {
    this.nev = nev;
    this.ertek = ertek;
  }

  public int compareTo(Csapat csapat) {
    if (this.ertek < csapat.ertek) {
      return -1;
    } else if (this.ertek > csapat.ertek) {
      return 1;
    } else {
      return 0;
    }
  }
}