TEKMA-RAZREDI

TEKMA-RAZREDI

Avtor: Petra Velikanje

BESEDILO NALOGE

Napišite razred Tekma za spremljanje košarkaške tekme. V razredu morate voditi imeni ekip, skupno število prekrškov na obeh straneh, koliko je bilo košev po 1, 2 in 3 točke ter dodati metodo za izpis statistike tekme. Doseganje košev (in prekrškov) implementirajte s pomočjo metod (npr. ZadelProstiMet(...), ZadelZa2Tocki(...)).

  • Dana je tabela trenutnih stanj tekem. Za vsako tekmo izpišite, katera ekipa vodi in za koliko točk.
  • Iz dane datoteke tekem izloči tiste, kjer je trenutni rezultat izenačen.
  • Izpišite imena tistih ekip, ki so v tem trenutku dosegle največ trojk.
  • Na vseh tekmah je domača ekipa dosegla trojko. Zabeleži to!
  • Izpiši statistiko tekme, kjer gostje vodijo za največ točk.
  • Dano tabelo tekem uredite tako, da bodo v njej urejeni dosežki glede na razliko med številom točk domače in gostujoče ekipe. Če imata dve tekmi enako razliko, zapišite prej tisto, ki ima večji posamezni dosežek

Vsi razredi naj obvezno vsebujejo

  1. Minimalni (tj. prazni) kontruktor public Razred(), ki tvori objekt s privzetimi (smiselnimi!) vrednostmi.
  2. Metodo public override string ToString(), ki vse podatke v objektu zapiše v obliki niza. Podatki naj bodo med seboj ločeni z znakom ';'.
  3. Polni konstruktor public Razred(string s), ki s klicem Razred(niz)generira tak objekt Razred r, za katerega velja niz = r.ToString().
  4. Metodo DodajNaDatoteko(string imeDatoteke), ki objekt this zapiše (oz. doda; glej metodo File.AppendText()) kot vrstico this.ToString()v tekstovni datoteki.
  5. Metodo PreberiZDatoteke(string imeDatoteke), ki vrne tabelo objektov, kjer posamezni objekt vsebuje podatke, ki so zapisani v posamezni vrstici tekstovne datoteke.
  6. Metodo IzpisiDatoteko(string imeDatoteke), ki izpiše vsebino datoteke.
  7. Metodo TvoriDatoteke(string imeDatoteke, int stElementov), ki tvori naključnodatoteko.
  8. Če je potrebno, napišite še metodo, ki izpiše tabelo elementov tega razreda

OPIS PROBLEMA IN IDEJA REŠITVE

Naloga od nas zahteva da s pomočjo razreda Tekma rešimo probleme, ki so podani v nalogi.

Najprej moramo napisati razred Tekma. Vseboval bo metode, ki nastavljajo spremenljivke v razredu in metode,katere vračajo vrednosti teh spremenljivk.

Nato pa s pomočjo razreda Tekma, napišemo še metode, ki nam poiščejo odgovore na zastavljena probleme.

RAZLAGA ALGORITMA

Reševanje naloge se lotimo tako da deklariramo vse spremenljivke v katerih bomo hranili podatke. Nato pa sestavimo še get in set metode s pomočjo katerih dostopamo do spremenljivk.

 public class Tekma
    {
        private string[] _imeEkipe=new string[2];//tabela imen ekip na košarkarski tekmi.

        /// <summary>
        /// Ime prve ekipe na košarkarski tekmi.
        /// </summary
        public string Ekipa1
        {
            get
            {//vrnemo podatek
                return _imeEkipe[0];
            }
            set
            {// nastavimo vrednost spremenljivke
                _imeEkipe[0]=value;
            }
        }

        /// <summary>
        /// Ime druge ekipe na košarkarski tekmi.
        /// </summary
        public string Ekipa2
        {
            get
            {//vrnemo podatek
                return _imeEkipe[1];
            }
            set
            {// nastavimo vrednost spremenljivke
                _imeEkipe[1]=value;
            }
        }

        private int[] _statistikaEkipa1=new int[4];//statistika prve ekipe na košarkarski tekmi
        /// <summary>
        /// Doseženi prosti meti prve ekipe
        /// </summary>
        /// <exception cref="System.ArgumentException">Se sproži, če je število prostih metov negativno.</exception>
        public int ProstiMet1
        {
            get
            {
                return _statistikaEkipa1[0];
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Število prostih metov ne more biti negativno.");
                }
                else
                {
                    _statistikaEkipa1[0] = value;
                }
            }
        }

        /// <summary>
        /// Doseženi meti za dve točki prve ekipe
        /// <exception cref="System.ArgumentException">Se sproži, če je število metov za dve točki negativno.</exception>
        public int MetZaDve1
        {
            get
            {
                return _statistikaEkipa1[1];
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Število metov za dve točke ne more biti negativno.");
                }
                else
                {
                    _statistikaEkipa1[1] = value;
                }
            }
        }

        /// <summary>
        /// Doseženi meti za tri točki prve ekipe
        /// </summary>
        /// <exception cref="System.ArgumentException">Se sproži, če je število metov za tri točki negativno.</exception>
        public int MetZaTri1
        {
            get
            {
                return _statistikaEkipa1[2];
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Število metov za tri točke ne more biti negativno.");
                }
                else
                {
                    _statistikaEkipa1[2] = value;
                }
            }
        }

        /// <summary>
        /// Narejeni prekrški
        /// </summary>
        /// <exception cref="System.ArgumentException">Se sproži, če je število prekrškov negativno.</exception>
        public int Prekrski1
        {
            get
            {
                return _statistikaEkipa1[3];
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Število prekrškov ne more biti negativno.");
                }
                else
                {
                    _statistikaEkipa1[3] = value;
                }
            }
        }

        private int[] _statistikaEkipa2 = new int[4];//statistika prve ekipe na košarkarski tekmi
        /// <summary>
        /// Doseženi prosti meti druge ekipe
        /// </summary>
        /// <exception cref="System.ArgumentException">Se sproži, če je število prostih metov negativno.</exception>
        public int ProstiMet2
        {
            get
            {
                return _statistikaEkipa2[0];
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Število prostih metov ne more biti negativno.");
                }
                else
                {
                    _statistikaEkipa2[0] = value;
                }
            }
        }

        /// <summary>
        /// Doseženi meti za dve točki druge ekipe
        /// </summary>
        /// <exception cref="System.ArgumentException">Se sproži, če je število metov za dve točki negativno.</exception>
        public int MetZaDve2
        {
            get
            {
                return _statistikaEkipa2[1];
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Število metov za dve točke ne more biti negativno.");
                }
                else
                {
                    _statistikaEkipa2[1] = value;
                }
            }
        }

        /// <summary>
        /// Doseženi meti za tri točki druge ekipe
        /// </summary>
        /// <exception cref="System.ArgumentException">Se sproži, če je število metov za tri točki negativno.</exception>
        public int MetZaTri2
        {
            get
            {
                return _statistikaEkipa2[2];
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Število metov za tri točke ne more biti negativno.");
                }
                else
                {
                    _statistikaEkipa2[2] = value;
                }
            }
        }

        /// <summary>
        /// Narejeni prekrški
        /// </summary
        /// <exception cref="System.ArgumentException">Se sproži, če je število prekrškov negativno.</exception>
        public int Prekrski2
        {
            get
            {
                return _statistikaEkipa2[3];
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Število prekrškov ne more biti negativno.");
                }
                else
                {
                    _statistikaEkipa2[3] = value;
                }
            }
        }

Nato znotraj razreda ustvarimo konstruktorje. Naloga od nas zahteva, da najprej ustvarimo minimalni konstruktor, ki ne vsebuje nobenega parametra. Nato ustvarimo polni konstruktor, kateremu moramo podati vse podatke. Na koncu pa ustvarimo še konstruktor katerega parameter je niz. V tem nizu pa so podatki ločeni s podpičjem.

    /// <summary>
        /// Minimalni konstruktor
        /// </summary>
        public Tekma()
        {
            Ekipa1 = "";
            Ekipa2 = "";
            MetZaDve1 = MetZaDve2 = 0;
            MetZaTri1 = MetZaTri2 = 0;
            Prekrski1 = Prekrski2 = 0;
            ProstiMet1 = ProstiMet2 = 0;
        }

        /// <summary>
        /// Polni konstruktor
        /// </summary>
        /// <param name="ekipa1">Ime prve ekipe</param>
        /// <param name="prekrsek1">Prekrški prve ekipe</param>
        /// <param name="prostiMet1">Mrosti meti prve ekipe</param>
        /// <param name="metZa21">Meti za dve točki prve točke</param>
        /// <param name="metZa31">Meti za tri točke prve ekipe</param>
        /// <param name="ekipa2">Ime druge ekipe</param>
        /// <param name="prekrsek2">Prekrški druge ekipe</param>
        /// <param name="prostiMet2">Mrosti meti druge ekipe</param>
        /// <param name="metZa22">Meti za dve točki druge točke</param>
        /// <param name="metZa32">Meti za tri točke druge ekipe</param>
        /// <exception cref="System.ArgumentException"></exception>
        /// <exception cref="System.Exception"></exception>
        public Tekma(string ekipa1, int prekrsek1, int prostiMet1, int metZa21, int metZa31, string ekipa2, int prekrsek2, int prostiMet2, int metZa22, int metZa32)
            :this()
        {
            Ekipa1 = ekipa1;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            Ekipa2 = ekipa2;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            Prekrski1 = prekrsek1;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            Prekrski2 = prekrsek2;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            ProstiMet1 = prostiMet1;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            ProstiMet2 = ProstiMet2;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            MetZaDve1 = metZa21;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            MetZaDve2 = metZa22;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            MetZaTri1 = metZa31;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.
            MetZaTri2 = MetZaTri2;//ker dostopamo preko lastnosti preverimo veljavnost vnesenega podatka.


        }

        /// <summary>
        /// Konstruktor, ki tvori nov izlet s pomočjo niza,

ki je v obliki, kot ga vrne metoda ToString()
        /// </summary>
        /// <param name="niz">Polna statistika košarkarske tekme, podatki so ločeni s podpičji</param>
        /// <exception cref="System.Exception">Se sproži, ko podatki niso pravilni.</exception>
        public Tekma(string niz)
        {
            string[] nizTab = niz.Split(';');
            //pogledamo ali imamo dovolj podatkov.
            if (nizTab.Length < 10)
            {
                throw new Exception("Premajhno število podanih parametrov.");
            }
            else
            {//podatke spremenimo tako, da so uporabni za naš razred.
                Ekipa1 = nizTab[0];
                int prekrsek1;
                if (int.TryParse(nizTab[1], out prekrsek1))
                {
                    Prekrski1 = prekrsek1;
                }
                else
                {
                    throw new Exception("Podatek ni število.");
                }

                int prostiMet1;
                if (int.TryParse(nizTab[2], out prostiMet1))
                {
                    ProstiMet1 = prostiMet1;
                }
                else
                {
                    throw new Exception("Podatek ni število.");
                }

                int metZa21;
                if (int.TryParse(nizTab[3], out metZa21))
                {
                    MetZaDve1 = metZa21;
                }
                else
                {
                    throw new Exception("Podatek ni število.");
                }

                int metZa31;
                if (int.TryParse(nizTab[4], out metZa31))
                {
                    MetZaTri1 = metZa31;
                }
                else
                {
                    throw new Exception("Podatek ni število.");
                }

                Ekipa2 = nizTab[5];
                int prekrsek2;
                if (int.TryParse(nizTab[6], out prekrsek2))
                {
                    Prekrski2 = prekrsek2;
                }
                else
                {
                    throw new Exception("Podatek ni število.");
                }

                int prostiMet2;
                if (int.TryParse(nizTab[7], out prostiMet2))
                {
                    ProstiMet2 = prostiMet2;
                }
                else
                {
                    throw new Exception("Podatek ni število.");
                }

                int metZa22;
                if (int.TryParse(nizTab[8], out metZa22))
                {
                    MetZaDve2 = metZa22;
                }
                else
                {
                    throw new Exception("Podatek ni število.");
                }

                int metZa32;
                if (int.TryParse(nizTab[9], out metZa32))
                {
                    MetZaTri2 = metZa32;
                }
                else
                {
                    throw new Exception("Podatek ni število.");
                }
            }
        }

RAZLAGA ALGORITMA

Nato spremenimo metodo ToString() tako, da so podatki ločeni s presledkom.

 /// <summary>
        /// izpis tekme.
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string izpis1 = Ekipa1.ToString() + ";" + Prekrski1.ToString() + ";" + ProstiMet1.ToString() + ";" + MetZaDve1.ToString() + ";" + MetZaTri1.ToString();
            string izpis2 = Ekipa2.ToString() + ";" + Prekrski2.ToString() + ";" + ProstiMet2.ToString() + ";" + MetZaDve2.ToString() + ";" + MetZaTri2.ToString();
            return izpis1+";"+izpis2;
        }

V nalogi so zahtevane tudi druge metode. Deklariramo še metode: DodajNaDatoteko(),PreberiZDatoteke(),IzpisiDatoteko() ter TvoriDatoteke();

    /// <summary>
        /// Metoda, ki trenutni objekt doda na datoteko, katere ime je podan kot parameter.
        /// </summary>
        /// <param name="imeDatoteke">Ime datoteke na katero zapišemo objekt.</param>
        public void DodajNaDatoteko(string imeDatoteke)
        {
            if (File.Exists(imeDatoteke))
            {//Če datoteka obstaja se povežemo z njo in dodamo željeni tekst.
                //povezavo nato zapremo
                StreamWriter pisi = File.AppendText(imeDatoteke);
                pisi.WriteLine(this.ToString());
                pisi.Close();
            }
            else
            {// če pa datoteka ne obstaja še, pa jo najprej ustvarimo in nato zapišemo tekst.
                StreamWriter pisi = File.CreateText(imeDatoteke);
                pisi.WriteLine(this.ToString());
                pisi.Close();
            }
        }

        /// <summary>
        /// Metoda, ki prebere objekt tipa Tekma z datoteke, katere ime je podano kot parameter.
        /// </summary>
        /// <param name="imeDatoteke">Ime datoteke s katere preberemo podatke..</param>
        /// <returns></returns>
        public Tekma[] PreberiZDatoteke(string imeDatoteke)
        {
            Tekma[] TabelaTekem = new Tekma[0];
            //povežemo se z datoteko
            StreamReader beri = File.OpenText(imeDatoteke);
            string vrstica = beri.ReadLine();
            string seznamTekem = "";
            //gremo skozi datoteko in vrstice zapisujemo v niz.
            //vrstice v nizu so ločene s dvopičjem.
            while (vrstica != null)
            {
                seznamTekem = seznamTekem + vrstica + ':';
                vrstica = beri.ReadLine();
            }
            //nizu odrežemo zadnje podpičje
            seznamTekem = seznamTekem.Substring(0, seznamTekem.Length - 1);
            //iz seznama vrstic naredimo tabelo vrstic.
            string[] tekme = seznamTekem.Split(':');
            Tekma[] Tekme = new Tekma[tekme.Length];
            //tabelo tipa string spremenimo v tabelo tipa Tekma
            for (int i = 0; i < tekme.Length; i++)
            {
                Tekme[i] = new Tekma(tekme[i]);
            }
            beri.Close();
            return Tekme;

        }

        /// <summary>
        /// Metoda, ki prebere trenutno vsebino podane datoteke.
        /// </summary>
        /// <param name="imeDatoteke">Ime datoteke s katere preberemo podatke.</param>
        public void IzpisiDatoteko(string imeDatoteke)
        {
            if (File.Exists(imeDatoteke))
            {//Če datoteka obstaja se povežemo z njo in dodamo željeni tekst.
                //povezavo nato zapremo
                StreamReader beri = File.OpenText(imeDatoteke);
                string izpis = beri.ReadToEnd();
                Console.Write(izpis);
                beri.Close();
            }
            else
            {
                Console.WriteLine("Datoteka " + imeDatoteke + " ne obstaja!");
            }
        }

        /// <summary>
        /// Metoda, ki tvori naključno datoteko.
        /// </summary>
        /// <param name="imeDatoteke">Ime datoteke na katero pišemo</param>
        /// <param name="StElementov">Koliko elemntov vsebuje.</param>
        public void TvoriDatoteke(string imeDatoteke, int StElementov)
        {
            string abeceda = "abcčdefghijklmnoprsštuvzž";
            Random naključno = new Random();
            StreamWriter pisi = File.CreateText(imeDatoteke);
            for (int i = 0; i < StElementov; i++)
            {
                //sestavimo ime za prvo ekipo
                string ime1 = "";
                int dolzina = naključno.Next(20);
                for (int k = 0; k < dolzina; k++)
                {
                    ime1 += abeceda[naključno.Next(0, abeceda.Length)];
                }

                //sestavimo ime za drugo ekipo
                string ime2 = "";
                for (int k = 0; k < dolzina; k++)
                {
                    ime2 += abeceda[naključno.Next(0, abeceda.Length)];
                }

                //naključno izberemo še število prekrškov, prostih metov, metov za dve in tri točke
                //za obe ekipi
                Tekma trenutna = new Tekma(ime1, naključno.Next(20), naključno.Next(20), naključno.Next(20), naključno.Next(20), ime2, naključno.Next(20), naključno.Next(20), naključno.Next(20), naključno.Next(20));
                pisi.WriteLine(trenutna.ToString());//zapišemo na datoteko

            }
            pisi.Close();//zapremo povezavo.
        }

RAZLAGA ALGORITMA

Metode ki pa sem jih sama dodala pa so:

  • statistika - izpiše nam statistiko tekme;
  • rezultat1 - vrne dosežene točke prve ekipe;

  • rezultat1 - vrne dosežene točke druge ekipe;

     /// <summary>
            /// izpiše statistiko košarkarske tekme.
            /// </summary>
            /// <returns></returns>
            public string statistika()
            {
                if ((Ekipa1 == "") && (Ekipa2 == ""))
                {
                    return "Tekme ni bilo!";
                }
                else
                {
                    string imeEkip = "Ime ekipe: " + Ekipa1 + " | " + Ekipa2 + '\n';
                    string prekrski = "Prekrski: " + Prekrski1 + " | " + Prekrski2 + '\n';
                    string prostiMet = "Prosti meti: " + ProstiMet1 + " | " + ProstiMet2 + '\n';
                    string metZaDve = "Meti za dve: " + MetZaDve1 + " | " + MetZaDve2 + '\n';
                    string metZaTri = "Meti za tri: " + MetZaTri1 + " | " + MetZaTri2 + '\n';
                    return imeEkip + prekrski + prostiMet + metZaDve + metZaTri;
                }
            }

            /// <summary>
            /// izračuna dosežene točke prve ekipe.
            /// </summary>
            /// <returns></returns>
            public int rezultat1()
            {
                return ProstiMet1 + MetZaDve1 * 2 + MetZaTri1 * 3;
            }

            /// <summary>
            /// izračuna dosežene točke druge ekipe.
            /// </summary>
            /// <returns></returns>
            public int rezultat2()
            {
                return ProstiMet2 + MetZaDve2 * 2 + MetZaTri2 * 3;
            }
        }

Za testiranje razreda Tekma pa potrebujemo še metode, ki nam odgovorijo na vprašanja v nalogi. Te pa so:

  • IzpisiTabelo - metoda, ki izpiše tabelo.
  • KdoInZaKolikoVodi - metoda, ki nam pove kdo vodi in za koliko
  • IzločiIzenačenja - metoda, ki iz datoteke izloči tekme ki so izenačene.
  • NajvečDoseženihTrojk - metoda, ki nam pove katere ekipe so dosegle največ trojk
  • GostjeVodijo - metoda, ki vrne statistiko, kjer gostje vodijo za največ točk.
 public static void IzpisiTabelo(Tekma[] tabelaTekem)
        {/*Metoda IzpisiTabelo() nam izpiše tabelo, katero podamo kot parameter.*/
            for (int i = 0; i < tabelaTekem.Length; i++)
            {
                Console.WriteLine("Tekma" + (i + 1) + ':');
                Console.WriteLine(tabelaTekem[i].statistika());
            }
        }

        public static void KdoInZaKolikoVodi(string imeDatoteke)
        {/*Metoda kdoInZaKolikoVodi() nam izpiše katera ekipa vodi in koliko znaša razlika.*/
            //gremo skozi tabelo
            if (File.Exists(imeDatoteke))
            {
                Tekma tekma=new Tekma();
                Tekma[] tabelaTekm = tekma.PreberiZDatoteke(imeDatoteke);
                for (int i = 0; i < tabelaTekm.Length; i++)
                {
                    int rezultat1 = tabelaTekm[i].rezultat1();
                    int rezultat2 = tabelaTekm[i].rezultat2();
                    if (rezultat1 <= rezultat2)//preverimo katera ekipa je nabrala več točk
                    {
                        int razlika = rezultat2 - rezultat1;//izračunamo razliko
                        //izpišemo ime ekipe in razliko
                        Console.WriteLine("Tekma " + (i + 1) + ": Vodi " + tabelaTekm[i].Ekipa1.ToString() + " za " + razlika + " točk");
                    }
                    else if (rezultat1 > rezultat2)
                    {
                        int razlika = rezultat1 - rezultat2;
                        Console.WriteLine("Tekma " + (i + 1) + ": Vodi " + tabelaTekm[i].Ekipa2.ToString() + " za " + razlika + " točk");
                    }
                }
            }
        }

        public static void IzlociIzenacenja(string imeDatoteke)
        {/*Metoda IzlociIzenačenja(imeDatoteke) nam iz datoteke izloči tiste tekme, kjer je trenutni rezultat izenačen.*/
            Tekma ena=new Tekma();
            Tekma[] trenutna = ena.PreberiZDatoteke(imeDatoteke);
            //Gremo skozi tabelo in iščemo izenačen rezultat.
            for (int i = 0; i < trenutna.Length; i++)
            {//izračunamo dosežene točke.
                int rezultat1 = trenutna[i].rezultat1();
                int rezultat2 = trenutna[i].rezultat2();
                if (rezultat1 == rezultat2)
                {
                    trenutna[i] = null;
                }
            }
            File.Delete(imeDatoteke);//na novo odpremo datoteko
            for (int i = 0; i < trenutna.Length; i++)
            {
                if (trenutna[i] != null)
                {
                    trenutna[i].DodajNaDatoteko(imeDatoteke);
                }
            }
        }

        public static void NajvecDosezenihTrojk(string imeDatoteke)
        {/*Metoda NajvecDosezenihTrojk() izpiše imena ekip, ki so v tem trenutku dosegle največ trojk.*/
            Tekma ena = new Tekma();
            Tekma[] tabelaTekem = ena.PreberiZDatoteke(imeDatoteke);
            string najvec = "";
            Console.WriteLine("Ekipe z največ trojkami:");
            for (int i = 0; i < tabelaTekem.Length; i++)
            {//Gremo skozi dano tabelo in pri tem gledamo katera ekipa je dosegla največ trojk.
                int trojka1 = tabelaTekem[i].MetZaTri1;
                int trojka2 = tabelaTekem[i].MetZaTri2;
                if (trojka1 < trojka2)
                {//ime ekipe dodamo na konec niza najvec. Imena ekip so ločena z vejico.
                    najvec += tabelaTekem[i].Ekipa2 + ", ";
                }
                najvec += tabelaTekem[i].Ekipa1 + ", ";
            }
            Console.WriteLine(najvec.Substring(0, najvec.Length - 2));
        }

        public  static void GostjeVodijo(string imeDatoteke)
        {/*Metoda gostjeVodijo(imeDatoteke) nam izpiše statistiko tekme, kjer gostje vodijo za največ točk.*/
            Tekma ena = new Tekma();
            Tekma[] trenutna = ena.PreberiZDatoteke(imeDatoteke);//datoteko prepišemo v tabelo.
            int največjaRazlika=0;
            int indeks=0;
            for (int i = 0; i < trenutna.Length; i++)
            {//izračunamo koliko točk je nabrala posamezna ekipa.
                int rezultat1 = trenutna[i].rezultat1();
                int rezultat2 = trenutna[i].rezultat2();
                //predpostavimo da so gostje prva ekipa
                if (((rezultat2 - rezultat1) > največjaRazlika)&&(največjaRazlika>=0))
                {
                    indeks = i;
                }
            }
            Console.WriteLine(trenutna[indeks].statistika());
        }

TESTNI PRIMERI

S pomočjo razreda Tekma bomo rešili probleme, ki so podani v nalogi. Ti pa so:

  • Dana je tabela trenutnih stanj tekem. Za vsako tekmo izpišite, katera ekipa vodi in za koliko točk.
  • Iz dane datoteke tekem izloči tiste, kjer je trenutni rezultat izenačen.
  • Izpišite imena tistih ekip, ki so v tem trenutku dosegle največ trojk.
  • Na vseh tekmah je domača ekipa dosegla trojko. Zabeleži to!
  • Izpiši statistiko tekme, kjer gostje vodijo za največ točk.
  • Dano tabelo tekem uredite tako, da bodo v njej urejeni dosežki glede na razliko med številom točk domače in gostujoče ekipe. Če imata dve tekmi enako razliko, zapišite prej tisto, ki ima večji posamezni dosežek


Tako bomo testirali razred Tekma.

TESTIRANJE RAZREDA - FILMČEK

0%
0%