Pravokotnik

Pravokotnik

Avtor: Matic Pogladič

Prva prosojnica

Besedilo naloge:

4. Pravokotnik Napišite razred Pravokotnik, s katerim predstavite pravokotnik v ravnini, katerega stranice so vzporedne koordinatnim osem, dolžine stranic pa cela števila. Kvadrat je predstavljen s koordinatama stredišča in dolžinama stranic.

  • Sestavite metodi za izračun ploščine in obsega kvadrata.
  • Izračunajte, koliko pravokotnikov ima ploščino manjšo od povprečne ploščine pravokotnikov v tabeli.
  • Vse pravokotnike v tabeli, ki jih lahko, spremenite v ploščinsko enake kvadrate. Npr. pravokotnik s stranicama 4 in 9 lahko spremenite v pravokotnik (kvadrat) s stranico 6, pravokotnika s stranicama 12 in 4 pa ni možno spremeniti v ploščinsko enak kvadrat, ki ima celoštevilsko dolžino stranic.
  • Iz žice izdelujemo modele pravokotnikov. Koliko cm žice potrebujemo, če želimo narediti vse pravokotnike v tabeli.
  • Napiši medodo, ki iz dane tabele pravokotnikov izloči vse, ki niso lepi. Pravokotnik je lep, če je razmerje med višino in dolžino (približno) enako zlatemu rezu

Razred naj vsebuje tudi:

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

Ideja rešitve

Ideja je, da bom ustvaril potrebne spremenljivke ustrezne konstruktorje za razred. V spremenljivkah bom v get metodah preveril njihovo ustreznost. En konstruktor bo tudi sprejel niz kot parameter. Nato bom ustvaril še metode za pisanje na datoteko, metodo za branje iz datoteke, metodo za izpis datoteke, metodo za ustvarjanje naključnih podatkov na datoteki, enostavne metode za obseg, ploščino in število pravokotnikov z podpovprečno ploščino. Ustvarilo bom tudi metodo, ki bo spremenila vse pravokotnike v kvadrate, če bo to celoštevilsko mogoče, metodo ToString, metodo, ki izračuna obseg vseh danih pravokotnikov, Na kocu bom še ustvaril metodo, ki iz seznama izloči vse pravokotnike, ki niso lepi.

Koda

Koda v razredu Pravokotnik:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace RazredPravokotnik
{
    /// <summary>
    /// Razred Pravokotnik
    /// </summary>
    public class Pravokotnik
    {
        private int _stranicaA;
        /// <summary>
        /// Stranica a pravokotnika
        /// </summary>
        public int stranicaA
        {
            get
            {
                return _stranicaA;
            }
            set
            {
                if (value <= 0)
                {
                    //Dolžina stranice mora biti pozitivna
                    throw new ArgumentException("Dolžina ne sme biti manjša od 0!");
                }
                else
                {
                    _stranicaA = value;
                }
            }
        }

        private int _stranicaB;
        /// <summary>
        /// Stranica b pravokotnika
        /// </summary>
        public int stranicaB
        {
            get
            {
                return _stranicaB;
            }
            set
            {
                if (value < 0)
                {
                    //Dolžina stranice mora biti pozitivna
                    throw new ArgumentException("Dolžina y ne sme biti manjša od 0!");
                }
                else
                {
                    _stranicaB = value;
                }
            }
        }


        private double _koordinataX;
        /// <summary>
        /// Koordinata središča pravokotnika po x osi
        /// </summary>
        public double koordinataX
        {
            get
            {
                return _koordinataX;
            }

            set
            {
                _koordinataX = value;
            }

        }

        private double _koordinataY;
        /// <summary>
        /// Koordinata središča pravokotnika po y osi
        /// </summary>
        public double koordinataY
        {
            get
            {
                return _koordinataY;
            }

            set
            {
                _koordinataY = value;
            }

        }


        /// <summary>
        /// Minimalni konstruktor
        /// </summary>
        public Pravokotnik()
        {
            _koordinataX = 0.0;
            _koordinataY = 0.0;
            _stranicaA = 1;
            _stranicaB = 1;
        }

        /// <summary>
        /// Konstruktor s parametroma veliosti stranic
        /// </summary>
        /// <param name="A">Velikost stranice a pravokotnika</param>
        /// <param name="B">Velikost stranice b pravokotnika</param>
        public Pravokotnik(int A, int B)
        {
            koordinataX = 0;
            koordinataY = 0;
            stranicaA = A;
            stranicaB = B;

        }

        /// <summary>
        /// Polni konstruktor, ki sprejme velikosti stranic in koordinate središča pravokotnika
        /// </summary>
        /// <param name="X">X koordinata središča pravokotnika</param>
        /// <param name="Y">Y koordinata središča pravokotnika</param>
        /// <param name="A">Velikost stranice a pravokotnika</param>
        /// <param name="B">Velikost stranice b pravokotnika</param>
        public Pravokotnik(double X,double Y,int A, int B)
        {
            koordinataX = X;
            koordinataY = Y;
            stranicaA = A;
            stranicaB = B;

        }

        /// <summary>
        /// Konstruktor, ki tvori nov pravokotnik s pomočjo niza, ki je v obliki, kot ga vrne metoda ToString()
        /// </summary>
        /// <param name="s">Poln opis pravokotnika, podatki ločeni s presledkom</param>
        public Pravokotnik(string s) : this()
        {
            string[] niz = s.Split(';');

            if (niz.Length != 4)
            {
                throw new Exception("Napačno število parametrov!");
            }

            else
            {
                int X;
                if (int.TryParse(niz[0], out X))
                    koordinataX = X; // ker dostopamo preko lastnosti, se kliče set in preveri veljavnost
                else
                    throw new Exception("X ni število.");

                int Y;
                if (int.TryParse(niz[1], out Y))
                    koordinataY = Y; // ker dostopamo preko lastnosti, se kliče set in preveri veljavnost
                else
                    throw new Exception("Y ni število.");

                int A;
                if (int.TryParse(niz[2], out A))
                    stranicaA = A; // ker dostopamo preko lastnosti, se kliče set in preveri veljavnost
                else
                    throw new Exception("A ni celo število.");

                int B;
                if (int.TryParse(niz[3], out B))
                    stranicaB = B; // ker dostopamo preko lastnosti, se kliče set in preveri veljavnost
                else
                    throw new Exception("B ni celo število.");
            }

        }

        /// <summary>
        /// Zapiše element na datoteko. Če datoteka ne obstaja, jo ustvari.
        /// </summary>
        /// <param name="imeDatoteke">Ime datoteke</param>
        public void PisiNaDatoteko(string imeDatoteke)
        {
            imeDatoteke = Environment.CurrentDirectory + "\\" + imeDatoteke;

            using (StreamWriter pisi = new StreamWriter(imeDatoteke, true))
            {
                pisi.WriteLine(this.ToString());
            }
        }

        /// <summary>
        /// Prebere vse vrstice datoteke in jih vrne kot objekte Pravokotnik v seznamu
        /// </summary>
        /// <param name="imeDatoteke">Ime datoteke</param>
        /// <returns>Seznam objektov</returns>
        public static List<Pravokotnik> beriIzDatoteke(string imeDatoteke)
        {
            imeDatoteke = Environment.CurrentDirectory + "\\" + imeDatoteke;

            if (!File.Exists(imeDatoteke))
                throw new FileNotFoundException("Datoteka ne obstaja");

            List<Pravokotnik> pravokotniki = new List<Pravokotnik>();

            using (StreamReader beri = new StreamReader(imeDatoteke))
            {
                string vrstica = "";

                while ((vrstica = beri.ReadLine()) != null)
                {
                    if (vrstica != "")
                    {
                        try
                        {
                            pravokotniki.Add(new Pravokotnik(vrstica));
                        }
                        catch (Exception e)
                        {

                            Console.WriteLine(e);
                        }

                    }

                }
            }

            return pravokotniki;
        }

        /// <summary>
        /// Izpis vsebine datoteke v konzolo
        /// </summary>
        /// <param name="imeDatoteke">Ime datoteke</param>
        public static void IzpisiDatoteko(string imeDatoteke)
        {
            imeDatoteke = Environment.CurrentDirectory + "\\" + imeDatoteke;

            using (StreamReader beri = new StreamReader(imeDatoteke))
            {
                string vrstica = "";
                while ((vrstica = beri.ReadLine()) != null)
                {
                    Console.WriteLine(vrstica);
                    Console.WriteLine("-----------");
                }
            }
        }

        public static void TvoriDatoteko(string imeDatoteke, int StElementov)
        {
            imeDatoteke = Environment.CurrentDirectory + "\\" + imeDatoteke;

            using (StreamWriter pisi = new StreamWriter(imeDatoteke, true))
            {
                Random gen = new Random();

                for (int i = 0; i < StElementov; i++)
                {
                    pisi.WriteLine("" + gen.NextDouble() + ";" + gen.NextDouble() + ";" + gen.Next(-100, 100) + ";" + gen.Next(-100, 100));
                }
            }


        }

        /// <summary>
        ///Metoda, ki izračuna ploščino Pravokotnika
        /// </summary>
        /// <returns>Ploščina pravokotnika</returns>
        public int ploscina()
        {
            return(this.stranicaA*this.stranicaB);
        }

        /// <summary>
        /// Metoda, ki izračuna obseg pravokotnika.
        /// </summary>
        /// <returns>Obseg pravokktonika</returns>
        public int obseg()
        {
            return (2 * this.stranicaA + 2 * this.stranicaB);
        }

        /// <summary>
        /// Metoda izračuna število pravokotnikov s podpovprečno ploščino
        /// </summary>
        /// <param name="seznamPravokotnikov">Seznam objektov Pravokotnik</param>
        /// <returns>Število podpovprečnih pravokotnikov v seznamu</returns>
        public static int steviloPodpovprecnih(Pravokotnik[] seznamPravokotnikov)
        {
            int vsota = 0;
            int stevilo = 0;

            //računanje vsote ploščin
            foreach (var item in seznamPravokotnikov)
            {
                vsota += item.ploscina();
            }

            //štetje podpovprečnih pravokotnikov
            foreach (var item in seznamPravokotnikov)
            {
                if (item.ploscina() < vsota/seznamPravokotnikov.Length)
                {
                    stevilo++;
                }
            }

            return stevilo;


        }

        /// <summary>
        /// Metoda spremeni vse pravokotnike v lepe kvadrate, če je to mogoče
        /// </summary>
        /// <param name="seznamPravokotnikov">Seznam objektov Pravokotnik</param>
        /// <returns>Seznam objektov Pravokotnik s spremenjenimi pravokotniki v lepe kvadrate</returns>
        public static Pravokotnik[] spremeniVKvadrate(Pravokotnik[] seznamPravokotnikov)
        {

            for (int i = 0; i < seznamPravokotnikov.Length; i++)
            {
                //koren iz produkta stranic
                double stranica = Math.Sqrt(seznamPravokotnikov[i].stranicaA * seznamPravokotnikov[i].stranicaB);

                //če je koren iz produkta stranic celo število, ga spremeni
                if (stranica % 1 == 0)
                {
                    seznamPravokotnikov[i] = new Pravokotnik(seznamPravokotnikov[i].koordinataX,seznamPravokotnikov[i].koordinataY,(int)stranica,(int)stranica);
                }
            }

            return seznamPravokotnikov;

        }

        /// <summary>
        /// Standardni izpis Pravokotnika
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return ("" + koordinataX.ToString() +";" + koordinataY.ToString() + ";" + stranicaA.ToString() + ";" + stranicaB.ToString());
        }




        public static int kolikoZice(Pravokotnik[] seznam)
        {
            int dolzina = 0;

            foreach (var item in seznam)
            {
                dolzina += item.obseg();
            }

            return dolzina;
        }

        //razmerje zlatega reza
        private static double razmerjeZlatiRez = (Math.Sqrt(5) + 1) / 2;


        /// <summary>
        /// Medoda, ki iz dane tabele pravokotnikov izloči vse, ki niso lepi, torej razmerje približno zlatemu rezu
        /// </summary>
        /// <param name="seznam">Seznam objektov Pravokotnik</param>
        /// <returns>Seznam lepih pravokotnikov</returns>
        public static Pravokotnik[] lepiPravokotniki(Pravokotnik[] seznam)
        {
            int st = 0;

            //štetje lepih
            for (int i = 0; i < seznam.Length; i++)
            {
                //če je razmerje a/b ali b/a v rangu +0.2, -0.2 od razmerja zlatega reza
                if ((double)seznam[i].stranicaB / seznam[i].stranicaA > razmerjeZlatiRez - 0.2 && (double)seznam[i].stranicaB / seznam[i].stranicaA < razmerjeZlatiRez + 0.2 || (double)seznam[i].stranicaA / seznam[i].stranicaB > razmerjeZlatiRez - 0.2 && (double)seznam[i].stranicaA / seznam[i].stranicaB < razmerjeZlatiRez + 0.2)
                {
                    st++;
                }
            }

            //nov seznam lepih Pravokotnikov
            Pravokotnik[] novSez = new Pravokotnik[st];

            int j = 0;

            //dodajanje v seznam
            for (int i = 0; i < seznam.Length; i++)
            {
                //če je razmerje a/b ali b/a v rangu +0.2, -0.2 od razmerja zlatega reza
                if ((double)seznam[i].stranicaB / seznam[i].stranicaA > razmerjeZlatiRez - 0.2 && (double)seznam[i].stranicaB / seznam[i].stranicaA < razmerjeZlatiRez + 0.2 || (double)seznam[i].stranicaA / seznam[i].stranicaB > razmerjeZlatiRez - 0.2 && (double)seznam[i].stranicaA / seznam[i].stranicaB < razmerjeZlatiRez + 0.2)
                {
                    novSez[j] = seznam[i];
                    j++;
                }
            }


            return novSez;
        }






    }
}

Koda v glavnem programu:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RazredPravokotnik;

namespace pravokotnik
{
    class Program
    {
        static void Main(string[] args)
        {

            Pravokotnik minimalni = new Pravokotnik();
            Console.WriteLine("Minimalni pravokotnik:");
            Console.WriteLine(minimalni.ToString());

            try
            {
                Pravokotnik negativenA = new Pravokotnik(-1, 1);
                Console.WriteLine(negativenA.ToString());

                Pravokotnik negativenB = new Pravokotnik(1, -1);
                Console.WriteLine(negativenB.ToString());
            }
            catch (Exception e)
            {

                Console.WriteLine(e.Message);
            }

            Pravokotnik prvi = new Pravokotnik(2,4);

            Pravokotnik drugi = new Pravokotnik(10,2,4, 9);

            Pravokotnik tretji = new Pravokotnik(1.2, -6.1, 8, 2);

            Pravokotnik cetrti = new Pravokotnik(9,4,3,6);

            Pravokotnik peti = new Pravokotnik(5, 3);

            Pravokotnik[] seznam = new Pravokotnik[6] {minimalni,prvi,drugi,tretji,cetrti,peti };

            Console.WriteLine("Potrebovali bi " + Pravokotnik.kolikoZice(seznam) + "cm žice.");

            Console.WriteLine("Obseg prvi:");

            Console.WriteLine("" + prvi.obseg().ToString());


            Console.WriteLine("Ploščina prvi:");

            Console.WriteLine("" + prvi.ploscina().ToString());

            Console.WriteLine("Seznam pravokotnikov:");
            foreach (var item in seznam)
            {
                Console.WriteLine(item.ToString());
                Console.WriteLine("-----------");
            }

            Console.WriteLine("Število pravokotnikov s podpovprečno ploščino je " + (Pravokotnik.steviloPodpovprecnih(seznam)));

            Pravokotnik[] novSez = Pravokotnik.spremeniVKvadrate(seznam);

            Console.WriteLine("Novi kvadrati:");
            foreach (var item in novSez)
            {
                Console.WriteLine(item.ToString());

                Console.WriteLine("-----------");
            }

            Console.WriteLine("Potrebovali bi " + Pravokotnik.kolikoZice(novSez) + "cm žice.");

            Console.WriteLine("Seznam lepih pravokotnikov: ");

            Pravokotnik[] lepi = Pravokotnik.lepiPravokotniki(seznam);

            foreach (var item in lepi)
            {
                Console.WriteLine(item.ToString());
                Console.WriteLine("-----------");
            }

            Pravokotnik nizni = new Pravokotnik(1,2,3,4);

            string nizniNiz = nizni.ToString();

            Console.WriteLine("Test konstruktorja ki prejme niz");

            Pravokotnik nizniDrugic = new Pravokotnik(nizniNiz);

            Console.WriteLine(nizniDrugic.ToString());


            nizniDrugic.PisiNaDatoteko("test.txt");

            List<Pravokotnik> pravList = Pravokotnik.beriIzDatoteke("test.txt");

            Console.WriteLine("Test branja iz datoteke in ToString():");

            foreach (var item in pravList)
            {
                Console.WriteLine(item.ToString());
                Console.WriteLine("-----------");
            }


            Console.WriteLine("Tvorjenje datoteke in njen izpis:");

            Pravokotnik.TvoriDatoteko("testNakljucna.txt", 10);

            Pravokotnik.IzpisiDatoteko("testNakljucna.txt");


            Console.ReadKey();
        }
    }
}

Testni primeri

0%
0%