# Shkenca > Informatikë dhe Internet > Arti i programimit >  Një lojë me një copë letër (drejtkëndësh ose katror)

## Urijan

Dy lojtareve u jepet nje cope leter (drejtkendesh ose katror). Njeri lojtar duhet ta prese ne mes kete cope letre (qe te fitohet perseri drejtekendesh ose katror), pjesen me te vogel e hudh ndersa pjesen me te madhe ia jep lojtarit tjeter. Lojtari tjeter poashtu ben nje prerje te drejte dhe pjesen me te madhe ia jep lojtarit kundershtar. Keshtu vazhdon loja, me kusht qe cdo lojtar te beje vetem nje prerje, derisa te zvogelohet copa e letres ne 1 cm2. Lojtari i cili e pranon letren me siperfaqe 1 cm2 eshte humbes, dtth. lojtari qe me prerjen e fundit krijon cope letre (sipas kushteve te dhena me larte) me siperfaqe 1 cm2 eshte fitues.
Pra kushtet ishin: qe cdo lojtar mund te beje vetem nje prerje njekohesisht, dhe kushti tjeter ishte qe pjesa me e madhe e letres mbahet ne loje, ndersa pjesa e vogel hudhet.

ne gjuhet programore C++ ose JAVA

----------


## hot_prinz

nuk po kuptoj,

nese prejm mu ne mes nje drejtkendesh ose katror, atehre nuk do te kete pjese te vogel ose pjese te madhe, por qe te dyat jane te barabarta, apo jo?

----------


## hot_prinz

por nese kemi nje leter 20 x 20cm dhe premjet behen ne menyre te rastesishme (randome) nga lojtaret, po e postoj shpejt e shpejt nje kod te pa optimuar ne C#:



```


        private void loja()
        {
            Random numri_random = new Random();
            int letra_x = 20;
            int letra_y = 20;
            string radha = "L1";
            int shuma_katrore = letra_x * letra_y;
            while (shuma_katrore > 1)
            {
            if (radha == "L1")
                {
                prej(ref shuma_katrore, ref letra_x, ref letra_y, "Lojtari i pare", numri_random);
                radha = "L2";
                }
            else
                {
                    prej(ref shuma_katrore, ref letra_x, ref letra_y, "Lojtari i dyte", numri_random);
                radha = "L1";
                }
            }
        }

       private void prej(ref int shuma_katrore, ref int letra_x, ref int letra_y, string p, Random numri_random)
       {
            int pika_ndarjes = 0;
            
            if (letra_x >= letra_y)
            {
                pika_ndarjes = numri_random.Next(1, letra_x);
                if (pika_ndarjes > (letra_x - pika_ndarjes))
                {
                    if ((pika_ndarjes * letra_y) > ((letra_x - pika_ndarjes) * letra_y))
                    {
                        shuma_katrore = pika_ndarjes * letra_y;
                        letra_x = pika_ndarjes;
                    }
                    else
                    {
                        shuma_katrore = (letra_x - pika_ndarjes) * letra_y;
                        letra_x = letra_x - pika_ndarjes;
                    }
                }
                else
                {
                    if ((pika_ndarjes * letra_y) > ((letra_x - pika_ndarjes) * letra_y))
                    {
                        shuma_katrore = pika_ndarjes * letra_y;
                        letra_x = pika_ndarjes;
                    }
                    else
                    {
                        shuma_katrore = (letra_x - pika_ndarjes) * letra_y;
                        letra_x = letra_x - pika_ndarjes;
                    }
                }
            }
            else
            {
                pika_ndarjes = numri_random.Next(1, letra_y);

                if (pika_ndarjes > (letra_y - pika_ndarjes))
                {
                    if ((pika_ndarjes * letra_x) > ((letra_y - pika_ndarjes) * letra_x))
                    {
                        shuma_katrore = pika_ndarjes * letra_x;
                        letra_y = pika_ndarjes;
                    }
                    else
                    {
                        shuma_katrore = (letra_y - pika_ndarjes) * letra_x;
                        letra_y = letra_y - pika_ndarjes;
                    }
                }
                else
                {
                    if ((pika_ndarjes * letra_x) > ((letra_y - pika_ndarjes) * letra_x))
                    {
                        shuma_katrore = pika_ndarjes * letra_x;
                        letra_y = pika_ndarjes;
                    }
                    else
                    {
                        shuma_katrore = (letra_y - pika_ndarjes) * letra_x;
                        letra_y = letra_y - pika_ndarjes;
                    }
                }
            }

            if (shuma_katrore <= 1)
                MessageBox.Show(p + " humbi duke marrur katrorin me siperfaqen (shuma katrore) " 
                    + shuma_katrore.ToString(), "Humbje!",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
            else
                MessageBox.Show(p + " muar katrorin me siperfaqen (shuma katrore) " 
                    + shuma_katrore.ToString(), "Informacion",
                        MessageBoxButtons.OK,MessageBoxIcon.Information);
           } 



```

----------


## hot_prinz

kodin me larte e postova shpejte pasi qe nuk pata kohe ta korigjoj shume, tani po vendos nje kod me te optimuar dhe te komentuar:



```


        private void loja()
        {
            Random numri_random = new Random();
            int gjatesia_letres_x = 20;
            int gjatesia_letres_y = 20;
            string radha_lojtarit = "L1";
            int shuma_katrore = gjatesia_letres_x * gjatesia_letres_y;

            //perderisa siperfaqja e letres eshte me e madhe se 1
            //letra do te prehet nga lojtari i cili e ka radhen
            while (shuma_katrore > 1)
            {
                if (radha_lojtarit == "L1")
                {
                    prej(ref shuma_katrore, ref gjatesia_letres_x, ref gjatesia_letres_y, 
                        "Lojtari i pare", numri_random);
                    radha_lojtarit = "L2";
                }
                else
                {
                    prej(ref shuma_katrore, ref gjatesia_letres_x, ref gjatesia_letres_y, 
                        "Lojtari i dyte", numri_random);
                    radha_lojtarit = "L1";
                }
            }

            //verifikimi dhe hudhja e informacionit se cilit lojtar te fundit
            //i mbeti katrori me siperfaqen prej 1cm²
            if (radha_lojtarit == "L1")
                MessageBox.Show("Lojtari i pare humbi lojen\n sepse i mbeti katrori me siperfaqen 1!"
                    , "Informacion", MessageBoxButtons.OK, MessageBoxIcon.Error);
            else
                MessageBox.Show("Lojtari i dyte humbi lojen\n sepse i mbeti katrori me siperfaqen 1!"
                    , "Informacion", MessageBoxButtons.OK, MessageBoxIcon.Error);

        }

        private void prej(ref int shuma_katrore, ref int gjatesia_letres_x, 
                            ref int gjatesia_letres_y, string p, Random numri_random)
        {
            int pika_ndarjes = 0;

            //nese eshte e mundur do ndajme letren ne anen me gjatesi me te madhe
            //nese gjatesia eshte e barabarte atehere do te fillojme ne koordinaten x
            if (gjatesia_letres_x >= gjatesia_letres_y)
            {
                //do nxjerrim nje numer random te plote ne gjatesi per te bere prerjen e letres
                pika_ndarjes = numri_random.Next(1, gjatesia_letres_x);

                //nese siperfaqja prej fillimit deri tek pika e prerjes * koordinata ne y
                //eshte me e madhe se siperfaqja e mbetur
                if ((pika_ndarjes * gjatesia_letres_y) > 
                    ((gjatesia_letres_x - pika_ndarjes) * gjatesia_letres_y))
                {
                    //vendosen siperfaqja katrore dhe gjatesia e re e anes se prere
                    //per letren e ndare me te madhe
                    shuma_katrore = pika_ndarjes * gjatesia_letres_y;
                    gjatesia_letres_x = pika_ndarjes;
                }
                else
                {
                    shuma_katrore = (gjatesia_letres_x - pika_ndarjes) * gjatesia_letres_y;
                    gjatesia_letres_x = gjatesia_letres_x - pika_ndarjes;
                }
            }
            else
            {
                pika_ndarjes = numri_random.Next(1, gjatesia_letres_y);

                if ((pika_ndarjes * gjatesia_letres_x) > 
                    ((gjatesia_letres_y - pika_ndarjes) * gjatesia_letres_x))
                {
                    shuma_katrore = pika_ndarjes * gjatesia_letres_x;
                    gjatesia_letres_y = pika_ndarjes;
                }
                else
                {
                    shuma_katrore = (gjatesia_letres_y - pika_ndarjes) * gjatesia_letres_x;
                    gjatesia_letres_y = gjatesia_letres_y - pika_ndarjes;
                }
            }

            //
            MessageBox.Show(p + " preu letren dhe fitoi katrorin me siperfaqe " + shuma_katrore.ToString()
                    , "Informacion", MessageBoxButtons.OK, MessageBoxIcon.Information);
        } 



```

----------


## Urijan

te faleminderit per kohen qe e ndat per te me ndihmur a do te kishte mundesi qe te ma leshoshe skedarin ne C#

----------


## hot_prinz

nese mendon skedarin e projekteve ne C# te Visual Studio 2008, ja ku e bashkangjis. 
Lojerat gjinden ne te njejtin projekt sepse nuk krijova dy projekte, duhesh vetem te aktivizosh/caktivizosh kodin.

----------


## Urijan

te faleminderit per mundin qe te me ndihmosh

----------


## Urijan

A do te mundeshte te me ndihmoni ne modifikimin e kesaj loje dhe ate ne keto rregulla:

letra te jete e madhesise m dhe n te cilat ti japim nga tastiera dhe po ashtu dhe prerjet ne siperfaqe njeri lojtar ti jape nga tastiera a lojtari tjeter te jet kompjuteri, po e pershkruaj per nje madhesi:
m=5 a n=60

qe te mundet te fitohet loja duhet te vendohen ca rregulla se pari duhet te krahasohet se cila eshte me e madhe m apo n, nese eshte n si ne rastin tone atehere numrat magjik jane : 5, 11, 23, 47

dhe nese pret lojtari nga n (60) por te mos harrojme se nuk mundet asnjeher te prese me shum se gjysma psh. nga 60 ai pret 12 dhe mbetet 48 a qe tre fitosh lojen duhet te kapesh 47 jo 48 nese arrin dhe kap njeren nga keto numra ti e fiton lojen ,

por lojtati mundet te prese edhe nga n me te njeten rregul jo me shum se gjysma ateher ndryshojne numrat magjik nese pret 1 mbesin 4 ateher numrat magjik jane : 4, 9, 19, .... ( m, 2m+1, 4m+3, ....), duhet te ruhet kjo rregull qe te fitoje kompjuteri cdo here .
nuk e di a po me kuputoni deri ketu nese nuk do arrini te me kuptoni do te mundohem te jap me shum sqarime 

DO JU JEM MIRENJOHES PER KETE NDIHME.


te shtoj dhe nje gje prerjet te jepen nga tastiera.

----------


## hot_prinz

e kam ndryshuar deri te numrat magjike, tani dy pyetje:

 - tek numrat magjike thua se nese njera ane e letres eshte = 60cm atehere numrat magjike jane 5,11,23,47. Pyetje, si jane numrat magjike nese ana e gjate e letres eshte 50cm ose 120cm, jane ende 5,11,23,47?

 - pastaj thua se lojtari nese pren letren me 1 atehere numrat magjike zbriten ne: 4, 9, 19, .... ( m, 2m+1, 4m+3, ....). E cfare nese lojtari nuk pren letren me 1 por me 37 atehere te gjithe numrat magjike me te vegjel se 37 do te behen negative, e  :xx: ?

projektin e ndrrova ne console-app*:



```


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

namespace Loja_letres
{
    class Program
    {
        static void Main(string[] args)
        {
            Random numri_random = new Random();

            shkruaj("\n\n     ************************************************",0);
            shkruaj("     ***                                          ***",0);
            shkruaj("     ***                 prej letrën!             ***", 0);
            shkruaj("     ***                                          ***",0);
            shkruaj("     ************************************************\n\n",1);

            shkruaj("shënoni madhësinë e letrës në x (vlerë numerike):", 1);
            int gjatesia_letres_x = int.Parse(Console.ReadLine());
            shkruaj("shënoni madhësinë e letrës në y (vlerë numerike):", 1);
            int gjatesia_letres_y = int.Parse(Console.ReadLine());
            shkruaj("shënoni emrin tuaj (psh: Brus-Lia :)):", 1);
            String strEmri = Console.ReadLine();
            string radha_lojtarit = strEmri;
            int shuma_katrore = gjatesia_letres_x * gjatesia_letres_y;

            while (shuma_katrore > 1)
            {
                if (radha_lojtarit == strEmri)
                {
                    shkruaj("\n\n-> në radhë është - " + strEmri, 1);
                    prej(ref shuma_katrore, ref gjatesia_letres_x, ref gjatesia_letres_y,
                        strEmri, numri_random);
                    radha_lojtarit = "L2";
                }
                else
                {
                    shkruaj("\n\n-> në radhë është - Kompjuteri (loz automatikisht)", 1);
                    prej(ref shuma_katrore, ref gjatesia_letres_x, ref gjatesia_letres_y,
                        "Kompjuteri", numri_random);
                    radha_lojtarit = strEmri;
                }
            }
            if (radha_lojtarit == strEmri)
                shkruaj("\n*\n*\n\n" + strEmri + " humbi lojën\n sepse i mbeti katrori me siperfaqën 1 cm²\n\n*\n*", 1);
            else
                shkruaj("\n*\n*\n\nKompjuteri humbi lojën\n sepse i mbeti katrori me siperfaqën 1 cm²\n\n*\n*", 1);
            shkruaj("\n\nshtyp një tastë në tastierë për të përfunduar lojën...", 1);
            Console.Read();
        }
        static void prej(ref int shuma_katrore, ref int gjatesia_letres_x,
                            ref int gjatesia_letres_y, string p, Random numri_random)
        {
            int pika_ndarjes = 0;

            if (gjatesia_letres_x >= gjatesia_letres_y)
            {
                if (p == "Kompjuteri")
                {
                    shkruaj("letra për tu prerë ka përmasat x=" + gjatesia_letres_x + "cm, y=" + gjatesia_letres_y + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_x * gjatesia_letres_y + "cm²", 1);
                    pika_ndarjes = numri_random.Next(1, (gjatesia_letres_x / 2));
                    shkruaj("Kompjuteri preu letrën në pikën " + pika_ndarjes + " të x-it", 1);
                }
                else
                {
                    shkruaj("letra për tu prerë ka përmasat x=" + gjatesia_letres_x + "cm, y=" + gjatesia_letres_y + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_x * gjatesia_letres_y + "cm²", 1);
                    shkruaj("në cilën pikë dëshironi të preni letrën në x?", 1);
                    shkruaj("(shkruaj një vlerë numerike prej 1 deri " + (gjatesia_letres_x / 2) + ")", 1);
                    pika_ndarjes = int.Parse(Console.ReadLine());
                    if (pika_ndarjes > (gjatesia_letres_x / 2))
                    {
                        shkruaj("gabim:\nzgjidh vetëm një vlerë numerike prej 1 deri " + (gjatesia_letres_x / 2), 1);
                        pika_ndarjes = int.Parse(Console.ReadLine());
                    }
                    shkruaj(p + " preu letrën në pikën " + pika_ndarjes + " të x-it", 1);
                }

                if ((pika_ndarjes * gjatesia_letres_y) >
                    ((gjatesia_letres_x - pika_ndarjes) * gjatesia_letres_y))
                {
                    shuma_katrore = pika_ndarjes * gjatesia_letres_y;
                    gjatesia_letres_x = pika_ndarjes;
                }
                else
                {
                    shuma_katrore = (gjatesia_letres_x - pika_ndarjes) * gjatesia_letres_y;
                    gjatesia_letres_x = gjatesia_letres_x - pika_ndarjes;
                }
            }
            else
            {
                if (p == "Kompjuteri")
                {
                    shkruaj("letra për tu prerë ka përmasat x=" + gjatesia_letres_x + "cm, y=" + gjatesia_letres_y + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_x * gjatesia_letres_y + "cm²", 1);
                    pika_ndarjes = numri_random.Next(1, (gjatesia_letres_y / 2));
                    shkruaj("Kompjuteri preu letrën në pikën " + pika_ndarjes + " të y-it", 1);
                }
                else
                {
                    shkruaj("letra për tu prerë ka përmasat x=" + gjatesia_letres_x + "cm, y=" + gjatesia_letres_y + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_x * gjatesia_letres_y + "cm²", 1);
                    shkruaj("në cilën pikë dëshironi të preni letrën në y?", 1);
                    shkruaj("(shkruaj një vlerë numerikë prej 1 deri " + (gjatesia_letres_y / 2) + ")", 1); 
                    pika_ndarjes = int.Parse(Console.ReadLine());
                    if (pika_ndarjes > (gjatesia_letres_y / 2))
                    {
                        shkruaj("gabim:\nzgjidh vetëm një vlerë numerike prej 1 deri " + (gjatesia_letres_y / 2), 1);
                        pika_ndarjes = int.Parse(Console.ReadLine());
                    }
                    shkruaj(p + " preu letrën në pikën " + pika_ndarjes + " te y-it", 1);
                }

                if ((pika_ndarjes * gjatesia_letres_x) >
                    ((gjatesia_letres_y - pika_ndarjes) * gjatesia_letres_x))
                {
                    shuma_katrore = pika_ndarjes * gjatesia_letres_x;
                    gjatesia_letres_y = pika_ndarjes;
                }
                else
                {
                    shuma_katrore = (gjatesia_letres_y - pika_ndarjes) * gjatesia_letres_x;
                    gjatesia_letres_y = gjatesia_letres_y - pika_ndarjes;
                }
            }
            shkruaj(p + " fitoi katrorin me siperfaqe " + shuma_katrore.ToString() + "cm²",1);
        }
        static void shkruaj(string p,int i)
        {
            Console.WriteLine(p);
            if(i>0)
            System.Threading.Thread.Sleep(1000);
        }
    }
} 



```

----------


## Urijan

po leshoj nje pershkrim te kesaj loje beso qe jam pak me i qart tani.

ju faleminderit per mundi qe po e jepni.

----------


## hot_prinz

- ende nuk gjeta pergjigje ne pyetjen e dyte,  cfare ndodh nese kompjuteri nuk pren 2 por 37? Atehere numrat magjike nuk jane {4, 9, 15, 39} por {-31, -26, -20, 2}, a duhet lejuar numrat magjike negative derisa nuk mund te perputhen me pikat e ndarjes numra pozitiv.

Perndryshe kodi deri tek zbritja e numrave magjike:



```


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

namespace Loja_letres
{
    class Program
    {
        public static ArrayList nr_magjike;
        public static bool bool_loja = true;

        static void Main(string[] args)
        {
            Random numri_random = new Random();

            shkruaj("\n\n     ************************************************",0);
            shkruaj("     ***                                          ***",0);
            shkruaj("     ***                 prej letrën!             ***", 0);
            shkruaj("     ***                                          ***",0);
            shkruaj("     ************************************************\n\n",1);

            shkruaj("shënoni madhësinë e letrës në m (vlerë numerike):", 1);
            int gjatesia_letres_m = int.Parse(Console.ReadLine());
            shkruaj("shënoni madhësinë e letrës në n (vlerë numerike):", 1);
            int gjatesia_letres_n = int.Parse(Console.ReadLine());
            shkruaj("shënoni emrin tuaj (psh: Brus-Lia :)):", 1);
            String strEmri = Console.ReadLine();
            string radha_lojtarit = strEmri;
            int shuma_katrore = gjatesia_letres_m * gjatesia_letres_n;

            bool perfundoi = false;

                while (shuma_katrore > 1 & perfundoi == false)
                {
                    if (bool_loja)
                    {
                        if (radha_lojtarit == strEmri)
                        {
                            shkruaj("\n\n-> në radhë është - " + strEmri, 1);
                            prej(ref shuma_katrore, ref gjatesia_letres_m, ref gjatesia_letres_n,
                                strEmri, numri_random);
                            if (bool_loja)
                                radha_lojtarit = "Kompjuteri";
                        }
                        else
                        {
                            shkruaj("\n\n-> në radhë është - Kompjuteri (loz automatikisht)", 1);
                            prej(ref shuma_katrore, ref gjatesia_letres_m, ref gjatesia_letres_n,
                                "Kompjuteri", numri_random);
                            if (bool_loja)
                                radha_lojtarit = strEmri;
                        }
                    }
                    else
                    {
                        if (radha_lojtarit == strEmri)
                        {
                            shkruaj("\n*\n*\n\n" + strEmri + " fitoi lojën\n sepse ndau letren ne nje numer magjik", 1);
                            string t1 = "   -> numrat_magjike ishin {"; 
                            for (int i = 0; i < nr_magjike.Count; i++)
                            {
                                if (i > 0)
                                    t1 += "," + nr_magjike[i];
                                else
                                    t1 += nr_magjike[i];
                            }
                            t1 += "}\n\n*\n*";
                            shkruaj(t1, 0);
                            perfundoi = true;
                        }
                        else
                        {
                            shkruaj("\n*\n*\n\nKompjuteri fitoi lojën\n sepse ndau letren ne nje numer magjik", 1);
                            string t1 = "   -> numrat_magjike ishin {";
                            for (int i = 0; i < nr_magjike.Count; i++)
                            {
                                if(i>0)
                                    t1 += "," + nr_magjike[i];
                                else
                                    t1 += nr_magjike[i];
                            }
                            t1 += "}\n\n*\n*";
                            shkruaj(t1, 0);
                            perfundoi = true;
                        }
                }
            }

            if (bool_loja)
            {
                if (radha_lojtarit == strEmri)
                    shkruaj("\n*\n*\n\n" + strEmri + " humbi lojën\n sepse i mbeti katrori me siperfaqën 1 cm²\n\n*\n*", 1);
                else
                    shkruaj("\n*\n*\n\nKompjuteri humbi lojën\n sepse i mbeti katrori me siperfaqën 1 cm²\n\n*\n*", 1);
            }

            shkruaj("\n\nshtyp një tastë në tastierë për të përfunduar lojën...", 1);
            Console.Read();
        }
        static void prej(ref int shuma_katrore, ref int gjatesia_letres_m,
                            ref int gjatesia_letres_n, string p, Random numri_random)
        {
            int pika_ndarjes = 0;

            if (gjatesia_letres_m >= gjatesia_letres_n)
            {
                if (p == "Kompjuteri")
                {
                    shkruaj("letra për tu prerë ka përmasat m=" + gjatesia_letres_m + "cm, n=" + gjatesia_letres_n + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_m * gjatesia_letres_n + "cm²", 1);

                    if ((gjatesia_letres_m != gjatesia_letres_n) & (gjatesia_letres_m > 1))
                        merr_nr_magjike(gjatesia_letres_m, gjatesia_letres_n);
                    else
                        nr_magjike = new ArrayList();

                    pika_ndarjes = numri_random.Next(1, (gjatesia_letres_m / 2));

                    for (int i = 0; i < nr_magjike.Count; i++)
                    {
                        if (pika_ndarjes == (int)nr_magjike[i])
                            bool_loja = false;
                    }
                    shkruaj("Kompjuteri preu letrën në pikën " + pika_ndarjes + " të m-it", 1);
                }
                else
                {
                    shkruaj("letra për tu prerë ka përmasat m=" + gjatesia_letres_m + "cm, n=" + gjatesia_letres_n + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_m * gjatesia_letres_n + "cm²", 1);
                    shkruaj("në cilën pikë dëshironi të preni letrën në m?", 1);
                    shkruaj("(shkruaj një vlerë numerike prej 1 deri " + (gjatesia_letres_m / 2) + ")", 1);

                    if ((gjatesia_letres_m != gjatesia_letres_n) & (gjatesia_letres_m >1))
                        merr_nr_magjike(gjatesia_letres_m, gjatesia_letres_n);
                    else
                        nr_magjike = new ArrayList();

                    pika_ndarjes = int.Parse(Console.ReadLine());

                    for (int i = 0; i < nr_magjike.Count; i++)
                    {
                        if (pika_ndarjes == (int)nr_magjike[i])
                            bool_loja = false;
                    }

                    if (pika_ndarjes > (gjatesia_letres_m / 2))
                    {
                        shkruaj("gabim:\nzgjidh vetëm një vlerë numerike prej 1 deri " + (gjatesia_letres_m / 2), 1);
                        pika_ndarjes = int.Parse(Console.ReadLine());
                    }
                    shkruaj(p + " preu letrën në pikën " + pika_ndarjes + " të m-it", 1);
                }

                if ((pika_ndarjes * gjatesia_letres_n) >
                    ((gjatesia_letres_m - pika_ndarjes) * gjatesia_letres_n))
                {
                    shuma_katrore = pika_ndarjes * gjatesia_letres_n;
                    gjatesia_letres_m = pika_ndarjes;
                }
                else
                {
                    shuma_katrore = (gjatesia_letres_m - pika_ndarjes) * gjatesia_letres_n;
                    gjatesia_letres_m = gjatesia_letres_m - pika_ndarjes;
                }
            }
            else
            {
                if (p == "Kompjuteri")
                {
                    shkruaj("letra për tu prerë ka përmasat m=" + gjatesia_letres_m + "cm, n=" + gjatesia_letres_n + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_m * gjatesia_letres_n + "cm²", 1);

                    if ((gjatesia_letres_m != gjatesia_letres_n) & (gjatesia_letres_n > 1))
                        merr_nr_magjike(gjatesia_letres_n, gjatesia_letres_m);
                    else
                        nr_magjike = new ArrayList();

                    pika_ndarjes = numri_random.Next(1, (gjatesia_letres_n / 2));

                    for (int i = 0; i < nr_magjike.Count; i++)
                    {
                        if (pika_ndarjes == (int)nr_magjike[i])
                            bool_loja = false;
                    }

                    shkruaj("Kompjuteri preu letrën në pikën " + pika_ndarjes + " të n-it", 1);
                }
                else
                {
                    shkruaj("letra për tu prerë ka përmasat m=" + gjatesia_letres_m + "cm, n=" + gjatesia_letres_n + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_m * gjatesia_letres_n + "cm²", 1);
                    shkruaj("në cilën pikë dëshironi të preni letrën në n?", 1);
                    shkruaj("(shkruaj një vlerë numerikë prej 1 deri " + (gjatesia_letres_n / 2) + ")", 1);

                    if ((gjatesia_letres_m != gjatesia_letres_n) & (gjatesia_letres_n > 1))
                        merr_nr_magjike(gjatesia_letres_n, gjatesia_letres_m);
                    else
                        nr_magjike = new ArrayList();

                    pika_ndarjes = int.Parse(Console.ReadLine());

                    for (int i = 0; i < nr_magjike.Count; i++)
                    {
                        if (pika_ndarjes == (int)nr_magjike[i])
                            bool_loja = false;
                    }

                    if (pika_ndarjes > (gjatesia_letres_n / 2))
                    {
                        shkruaj("gabim:\nzgjidh vetëm një vlerë numerike prej 1 deri " + (gjatesia_letres_n / 2), 1);
                        pika_ndarjes = int.Parse(Console.ReadLine());
                    }
                    shkruaj(p + " preu letrën në pikën " + pika_ndarjes + " te n-it", 1);
                }

                if ((pika_ndarjes * gjatesia_letres_m) >
                    ((gjatesia_letres_n - pika_ndarjes) * gjatesia_letres_m))
                {
                    shuma_katrore = pika_ndarjes * gjatesia_letres_m;
                    gjatesia_letres_n = pika_ndarjes;
                }
                else
                {
                    shuma_katrore = (gjatesia_letres_n - pika_ndarjes) * gjatesia_letres_m;
                    gjatesia_letres_n = gjatesia_letres_n - pika_ndarjes;
                }
            }
            shkruaj(p + " fitoi katrorin me siperfaqe " + shuma_katrore.ToString() + "cm²",1);
            string t1 = "   -> numrat_magjike ishin {";
            if (nr_magjike.Count > 0)
            {
                for (int i = 0; i < nr_magjike.Count; i++)
                {
                    if (i > 0)
                        t1 += "," + nr_magjike[i];
                    else
                        t1 += nr_magjike[i];
                }
                t1 += "}";
                shkruaj(t1, 1);
            }
            else
            {
                shkruaj("   -> ska numra magjike, sepse anet e letres jane te barabarta!",0);
            }
        }
        static void merr_nr_magjike(int i, int j)
        {
            if (j > 1)
            {
                int iTemp = j;
                nr_magjike = new ArrayList();

                nr_magjike.Add(j);
                for (int x = 1; x < i; x++)
                {
                    if ((2 * iTemp) + 1 < i)
                    {
                        iTemp = (2 * iTemp) + 1;
                        nr_magjike.Add(iTemp);
                    }
                }
            }
        }
        static void shkruaj(string p, int i)
        {
            Console.WriteLine(p);
            if(i>0)
            System.Threading.Thread.Sleep(1000);
        }
    }
} 



```

----------


## Urijan

ne cfare pjeste pret me 37 nese m=6 dhe n=60 ai nuk mund te prese me shum se gjysma
dhe nuk mund te prese me te vogel se 1. mendon ne m te prese 37 apo ne n

ne pjesen e "m" ku m=6 ai nuk mund te prese ne ate pje me shum se 3, dhe nese pret vetem nga m, ateher m mund te arrije deri ne 1 me e vogel se 1 nuk mudet dhe nese arrin ta beje m=1 ateher numrat magjik jane
1, 3, 7, 15, 31,.... numrat magjik mvaren vetem nga me e vogla

do te duhet qe ti jepet mundesia lojtarit te prese edhe na n edhe nga m

----------


## hot_prinz

ne rregull 37 eshte me shume se gjysma e 55, po cfare nese kompjuteri pret 25 ne n=55? Atehere 5-25 = -20 apo jo?

----------


## Urijan

55-25 = 30 dhe mbetet 30
pse mendon 5-25

----------


## hot_prinz

***me duket se jam keqkuptuar me zbritjen, natyrisht se numrat magjike llogariten perseri sipas pjeses me te vogel qe mbetet para se te prehet perseri.

versioni si eshte tani duhet ti kryeje te gjitha nevojat tua!.

----------


## Urijan

po
do me ndihmoje shume

----------


## Urijan

a do te mundeshte qe te preheshte letra ne te dyja pjeset te kishte nje opcion ne cilen ane don ta presesh letren nga m apo n.

----------


## hot_prinz

tani kompjuteri zgjedh anen rastsisht/random, kurse per lojtarin mund te zgjedh 1 per anen m dhe 2 per anen n.



```


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

namespace Loja_letres
{
    class Program
    {
        public static ArrayList nr_magjike;
        public static bool bool_loja = true;

        static void Main(string[] args)
        {
            Random numri_random = new Random();

            shkruaj("\n\n     ************************************************",0);
            shkruaj("     ***                                          ***",0);
            shkruaj("     ***                 prej letrën!             ***", 0);
            shkruaj("     ***                                          ***",0);
            shkruaj("     ************************************************\n\n",1);

            shkruaj("shënoni madhësinë e letrës në m (vlerë numerike):", 1);
            int gjatesia_letres_m = int.Parse(Console.ReadLine());
            shkruaj("shënoni madhësinë e letrës në n (vlerë numerike):", 1);
            int gjatesia_letres_n = int.Parse(Console.ReadLine());
            shkruaj("shënoni emrin tuaj (psh: Brus-Lia :)):", 1);
            String strEmri = Console.ReadLine();
            string radha_lojtarit = strEmri;
            int shuma_katrore = gjatesia_letres_m * gjatesia_letres_n;

            bool perfundoi = false;

                while (shuma_katrore > 1 & perfundoi == false)
                {
                    if (bool_loja)
                    {
                        if (radha_lojtarit == strEmri)
                        {
                            shkruaj("\n\n-> në radhë është - " + strEmri, 1);
                            prej(ref shuma_katrore, ref gjatesia_letres_m, ref gjatesia_letres_n,
                                strEmri, numri_random);
                            if (bool_loja)
                                radha_lojtarit = "Kompjuteri";
                        }
                        else
                        {
                            shkruaj("\n\n-> në radhë është - Kompjuteri (loz automatikisht)", 1);
                            prej(ref shuma_katrore, ref gjatesia_letres_m, ref gjatesia_letres_n,
                                "Kompjuteri", numri_random);
                            if (bool_loja)
                                radha_lojtarit = strEmri;
                        }
                    }
                    else
                    {
                        if (radha_lojtarit == strEmri)
                        {
                            shkruaj("\n*\n*\n\n" + strEmri + " fitoi lojën\n sepse ndau letren ne nje numer magjik", 1);
                            string t1 = "   -> numrat_magjike ishin {"; 
                            for (int i = 0; i < nr_magjike.Count; i++)
                            {
                                if (i > 0)
                                    t1 += "," + nr_magjike[i];
                                else
                                    t1 += nr_magjike[i];
                            }
                            t1 += "}\n\n*\n*";
                            shkruaj(t1, 0);
                            perfundoi = true;
                        }
                        else
                        {
                            shkruaj("\n*\n*\n\nKompjuteri fitoi lojën\n sepse ndau letren ne nje numer magjik", 1);
                            string t1 = "   -> numrat_magjike ishin {";
                            for (int i = 0; i < nr_magjike.Count; i++)
                            {
                                if(i>0)
                                    t1 += "," + nr_magjike[i];
                                else
                                    t1 += nr_magjike[i];
                            }
                            t1 += "}\n\n*\n*";
                            shkruaj(t1, 0);
                            perfundoi = true;
                        }
                }
            }

            if (bool_loja)
            {
                if (radha_lojtarit == strEmri)
                    shkruaj("\n*\n*\n\n" + strEmri + " humbi lojën\n sepse i mbeti katrori me siperfaqën 1 cm²\n\n*\n*", 1);
                else
                    shkruaj("\n*\n*\n\nKompjuteri humbi lojën\n sepse i mbeti katrori me siperfaqën 1 cm²\n\n*\n*", 1);
            }

            shkruaj("\n\nshtyp një tastë në tastierë për të përfunduar lojën...", 1);
            Console.Read();
        }
        static void prej(ref int shuma_katrore, ref int gjatesia_letres_m,
                            ref int gjatesia_letres_n, string p, Random numri_random)
        {
            int pika_ndarjes = 0;

                if (p == "Kompjuteri")
                {
                    shkruaj("letra për tu prerë ka përmasat m=" + gjatesia_letres_m + "cm, n=" + gjatesia_letres_n + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_m * gjatesia_letres_n + "cm²", 1);

                    if ((gjatesia_letres_m != gjatesia_letres_n) & (gjatesia_letres_m > 1))
                        merr_nr_magjike(gjatesia_letres_m, gjatesia_letres_n);
                    else
                        nr_magjike = new ArrayList();

                    int ana_ndarjes = numri_random.Next(1, 2);
                    switch (ana_ndarjes)
                    { 
                        case 1:
                            pika_ndarjes = numri_random.Next(1, (gjatesia_letres_m / 2));
                            shkruaj("Kompjuteri - preu ne anen m!", 1);
                            break;
                        case 2:
                            pika_ndarjes = numri_random.Next(1, (gjatesia_letres_n / 2));
                            shkruaj("Kompjuteri - preu ne anen n!", 1);
                            break;
                    }

                    for (int i = 0; i < nr_magjike.Count; i++)
                    {
                        if (pika_ndarjes == (int)nr_magjike[i])
                            bool_loja = false;
                    }
                    shkruaj("Kompjuteri preu letrën në pikën " + pika_ndarjes + " të m-it", 1);
                }
                else
                {
                    shkruaj("letra për tu prerë ka përmasat m=" + gjatesia_letres_m + "cm, n=" + gjatesia_letres_n + "cm"
                        + " ose një sipërfaqe " + gjatesia_letres_m * gjatesia_letres_n + "cm²", 1);
                    shkruaj("në cilën pikë dëshironi të preni letrën në m?", 1);
                    shkruaj("(shkruaj një vlerë numerike prej 1 deri " + (gjatesia_letres_m / 2) + ")", 1);

                    if ((gjatesia_letres_m != gjatesia_letres_n) & (gjatesia_letres_m >1))
                        merr_nr_magjike(gjatesia_letres_m, gjatesia_letres_n);
                    else
                        nr_magjike = new ArrayList();

                    pika_ndarjes = int.Parse(Console.ReadLine());
                    shkruaj("(shkruaj <1> per prere anen m dhe <2> per te prere anen n)", 1);
                    int ana_ndarjes = int.Parse(Console.ReadLine());
                    switch (ana_ndarjes)
                    {
                        case 1:
                            pika_ndarjes = numri_random.Next(1, (gjatesia_letres_m / 2));
                            shkruaj(p + " - preu ne anen m!", 1);
                            break;
                        case 2:
                            pika_ndarjes = numri_random.Next(1, (gjatesia_letres_n / 2));
                            shkruaj(p + " - preu ne anen n!", 1);
                            break;
                    }

                    for (int i = 0; i < nr_magjike.Count; i++)
                    {
                        if (pika_ndarjes == (int)nr_magjike[i])
                            bool_loja = false;
                    }

                    if (pika_ndarjes > (gjatesia_letres_m / 2))
                    {
                        shkruaj("gabim:\nzgjidh vetëm një vlerë numerike prej 1 deri " + (gjatesia_letres_m / 2), 1);
                        pika_ndarjes = int.Parse(Console.ReadLine());
                    }
                    shkruaj(p + " preu letrën në pikën " + pika_ndarjes + " të m-it", 1);
                }

                if ((pika_ndarjes * gjatesia_letres_n) >
                    ((gjatesia_letres_m - pika_ndarjes) * gjatesia_letres_n))
                {
                    shuma_katrore = pika_ndarjes * gjatesia_letres_n;
                    gjatesia_letres_m = pika_ndarjes;
                }
                else
                {
                    shuma_katrore = (gjatesia_letres_m - pika_ndarjes) * gjatesia_letres_n;
                    gjatesia_letres_m = gjatesia_letres_m - pika_ndarjes;
                }

            shkruaj(p + " fitoi katrorin me siperfaqe " + shuma_katrore.ToString() + "cm²",1);
            string t1 = "   -> numrat_magjike ishin {";
            if (nr_magjike.Count > 0)
            {
                for (int i = 0; i < nr_magjike.Count; i++)
                {
                    if (i > 0)
                        t1 += "," + nr_magjike[i];
                    else
                        t1 += nr_magjike[i];
                }
                t1 += "}";
                shkruaj(t1, 1);
            }
            else
            {
                shkruaj("   -> ska numra magjike, sepse anet e letres jane te barabarta!",0);
            }
        }
        static void merr_nr_magjike(int i, int j)
        {
            if (j > 1)
            {
                int iTemp = j;
                nr_magjike = new ArrayList();

                nr_magjike.Add(j);
                for (int x = 1; x < i; x++)
                {
                    if ((2 * iTemp) + 1 < i)
                    {
                        iTemp = (2 * iTemp) + 1;
                        nr_magjike.Add(iTemp);
                    }
                }
            }
        }
        static void shkruaj(string p, int i)
        {
            Console.WriteLine(p);
            if(i>0)
            System.Threading.Thread.Sleep(1000);
        }
    }
} 



```

----------


## hot_prinz

gjate ndryshimit te kodit nga prerja automatike ne anen me te madhe, ne prerjen randome te kompjuterit ose asaj te lirshme nga lojtari, duke e provuar kodin rastesisht hasa ne gabime kur ana n eshte me e madhe se ana m (mbreme e pata provuar vetem kur m eshte me e madhe se n, dmth. te kunderten) per kete arsye me u desh ta ndryshoja kodin perseri:



```


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

namespace Loja_letres 
{ 
    class Program 
    { 
        public static ArrayList nr_magjike; 
        public static bool bool_loja = true; 

        static void Main(string[] args) 
        { 
            Random numri_random = new Random(); 

            shkruaj("\n\n     ************************************************",0); 
            shkruaj("     ***                                          ***",0); 
            shkruaj("     ***                 prej letrën!             ***", 0); 
            shkruaj("     ***                                          ***",0); 
            shkruaj("     ************************************************\n\n",1); 

            shkruaj("shënoni madhësinë e letrës në m (vlerë numerike):", 1); 
            int gjatesia_letres_m = int.Parse(Console.ReadLine()); 
            shkruaj("shënoni madhësinë e letrës në n (vlerë numerike):", 1); 
            int gjatesia_letres_n = int.Parse(Console.ReadLine()); 
            shkruaj("shënoni emrin tuaj (psh: Brus-Lia :)):", 1); 
            String strEmri = Console.ReadLine(); 
            string radha_lojtarit = strEmri; 
            int shuma_katrore = gjatesia_letres_m * gjatesia_letres_n; 

            bool perfundoi = false; 

                while (shuma_katrore > 1 & perfundoi == false) 
                { 
                    if (bool_loja) 
                    { 
                        if (radha_lojtarit == strEmri) 
                        { 
                            shkruaj("\n\n-> në radhë është - " + strEmri, 1); 
                            prej(ref shuma_katrore, ref gjatesia_letres_m, ref gjatesia_letres_n, 
                                strEmri, numri_random); 
                            if (bool_loja) 
                                radha_lojtarit = "Kompjuteri"; 
                        } 
                        else 
                        { 
                            shkruaj("\n\n-> në radhë është - Kompjuteri (loz automatikisht)", 1); 
                            prej(ref shuma_katrore, ref gjatesia_letres_m, ref gjatesia_letres_n, 
                                "Kompjuteri", numri_random); 
                            if (bool_loja) 
                                radha_lojtarit = strEmri; 
                        } 
                    } 
                    else 
                    { 
                        if (radha_lojtarit == strEmri) 
                        { 
                            shkruaj("\n*\n*\n\n" + strEmri + " fitoi lojën\n sepse ndau letren ne nje numer magjik", 1); 
                            string t1 = "   -> numrat_magjike ishin {";  
                            for (int i = 0; i < nr_magjike.Count; i++) 
                            { 
                                if (i > 0) 
                                    t1 += "," + nr_magjike[i]; 
                                else 
                                    t1 += nr_magjike[i]; 
                            } 
                            t1 += "}\n\n*\n*"; 
                            shkruaj(t1, 0); 
                            perfundoi = true; 
                        } 
                        else 
                        { 
                            shkruaj("\n*\n*\n\nKompjuteri fitoi lojën\n sepse ndau letren ne nje numer magjik", 1); 
                            string t1 = "   -> numrat_magjike ishin {"; 
                            for (int i = 0; i < nr_magjike.Count; i++) 
                            { 
                                if(i>0) 
                                    t1 += "," + nr_magjike[i]; 
                                else 
                                    t1 += nr_magjike[i]; 
                            } 
                            t1 += "}\n\n*\n*"; 
                            shkruaj(t1, 0); 
                            perfundoi = true; 
                        } 
                } 
            } 

            if (bool_loja) 
            { 
                if (radha_lojtarit == strEmri) 
                    shkruaj("\n*\n*\n\n" + strEmri + " humbi lojën\n sepse i mbeti katrori me siperfaqën 1 cm²\n\n*\n*", 1); 
                else 
                    shkruaj("\n*\n*\n\nKompjuteri humbi lojën\n sepse i mbeti katrori me siperfaqën 1 cm²\n\n*\n*", 1); 
            } 

            shkruaj("\n\nshtyp një tastë në tastierë për të përfunduar lojën...", 1); 
            Console.Read(); 
        } 
        static void prej(ref int shuma_katrore, ref int gjatesia_letres_m, 
                            ref int gjatesia_letres_n, string p, Random numri_random) 
        { 
            int pika_ndarjes = 0;
            bool m = false;
            bool n = false;

                if (p == "Kompjuteri") 
                { 
                    shkruaj("letra për tu prerë ka përmasat m=" + gjatesia_letres_m + "cm, n=" + gjatesia_letres_n + "cm" 
                        + " ose një sipërfaqe " + gjatesia_letres_m * gjatesia_letres_n + "cm²", 1); 

                    if (gjatesia_letres_m != gjatesia_letres_n) 
                        merr_nr_magjike(gjatesia_letres_m, gjatesia_letres_n); 
                    else 
                        nr_magjike = new ArrayList(); 

                    int ana_ndarjes = numri_random.Next(1, 2);

                    switch (ana_ndarjes)
                        {
                        case 1:
                            if (gjatesia_letres_m == 1)
                                {
                                ana_ndarjes = 2;
                                shkruaj("   -> ana m nuk ben te ndahet sepse ka vleren 1!  <--<", 1);
                                }
                            break;
                        case 2:
                            if (gjatesia_letres_n == 1)
                                {
                                ana_ndarjes = 1;
                                shkruaj("   -> ana n nuk ben te ndahet sepse ka vleren 1!  <--<", 1);
                                }
                            break;
                        }

                    switch (ana_ndarjes) 
                    {  
                        case 1:
                            pika_ndarjes = numri_random.Next(1, (gjatesia_letres_m / 2));
                            shkruaj("Kompjuteri - preu ne anen m!", 1);
                            shkruaj("Kompjuteri preu letrën në pikën " + pika_ndarjes + " të m-it", 1); 
                            m = true;

                            break; 
                        case 2:
                                pika_ndarjes = numri_random.Next(1, (gjatesia_letres_n / 2));
                                shkruaj("Kompjuteri - preu ne anen n!", 1);
                                shkruaj("Kompjuteri preu letrën në pikën " + pika_ndarjes + " të n-it", 1); 
                                n = true;
                            break; 
                    } 

                    for (int i = 0; i < nr_magjike.Count; i++) 
                    { 
                        if (pika_ndarjes == (int)nr_magjike[i]) 
                            bool_loja = false; 
                    } 
                } 
                else 
                { 
                    shkruaj("letra për tu prerë ka përmasat m=" + gjatesia_letres_m + "cm, n=" + gjatesia_letres_n + "cm" 
                        + " ose një sipërfaqe " + gjatesia_letres_m * gjatesia_letres_n + "cm²", 1);


                    shkruaj("(shkruaj <1> per prere anen m dhe <2> per te prere anen n)", 1);
                    int ana_ndarjes = int.Parse(Console.ReadLine());

                    switch (ana_ndarjes)
                        {
                        case 1:
                            if (gjatesia_letres_m == 1)
                                {
                                ana_ndarjes = 2;
                                shkruaj("   -> ana m nuk ben te ndahet sepse ka vleren 1!  <--<", 1);
                                }
                            break;
                        case 2:
                            if (gjatesia_letres_n == 1)
                                {
                                ana_ndarjes = 1;
                                shkruaj("   -> ana n nuk ben te ndahet sepse ka vleren 1!  <--<", 1);
                                }
                            break;
                        }

                    switch (ana_ndarjes)
                        {
                        case 1:
                            if (gjatesia_letres_m > 1)
                                {
                                pika_ndarjes = numri_random.Next(1, (gjatesia_letres_m / 2));
                                shkruaj(p + " - preu ne anen m!", 1);
                                shkruaj("në cilën pikë dëshironi të preni letrën në m?", 1);
                                shkruaj("(shkruaj një vlerë numerike prej 1 deri " + (gjatesia_letres_m / 2) + ")", 1);
                                pika_ndarjes = int.Parse(Console.ReadLine());
                                while (pika_ndarjes >(gjatesia_letres_m/2))
                                    {
                                    shkruaj("(Verejtje -> shkruaj vetem një vlerë numerike prej 1 deri " + (gjatesia_letres_m / 2) + ")", 1);
                                    pika_ndarjes = int.Parse(Console.ReadLine());
                                    }
                                shkruaj(p + " preu letrën në pikën " + pika_ndarjes + " të m-it", 1);
                                m = true;

                                }
                                break;

                        case 2:
                            if (gjatesia_letres_n > 1)
                                {
                                pika_ndarjes = numri_random.Next(1, (gjatesia_letres_n / 2));
                                shkruaj(p + " - preu ne anen n!", 1);
                                shkruaj("në cilën pikë dëshironi të preni letrën në n?", 1);
                                shkruaj("(shkruaj një vlerë numerike prej 1 deri " + (gjatesia_letres_n / 2) + ")", 1);
                                pika_ndarjes = int.Parse(Console.ReadLine());
                                while (pika_ndarjes > (gjatesia_letres_n / 2))
                                    {
                                    shkruaj("(Verejtje -> shkruaj vetem një vlerë numerike prej 1 deri " + (gjatesia_letres_n / 2) + ")", 1);
                                    pika_ndarjes = int.Parse(Console.ReadLine());
                                    }
                                shkruaj(p + " preu letrën në pikën " + pika_ndarjes + " të n-it", 1);
                                n = true;
                                }
                            break;
                        } 

                    if (gjatesia_letres_m != gjatesia_letres_n) 
                        merr_nr_magjike(gjatesia_letres_m, gjatesia_letres_n); 
                    else 
                        nr_magjike = new ArrayList(); 


                    for (int i = 0; i < nr_magjike.Count; i++) 
                    { 
                        if (pika_ndarjes == (int)nr_magjike[i]) 
                            bool_loja = false; 
                    }  
                }

                if (m)
                {
                if ((pika_ndarjes * gjatesia_letres_n) >
                        ((gjatesia_letres_m - pika_ndarjes) * gjatesia_letres_n))
                    {
                    shuma_katrore = pika_ndarjes * gjatesia_letres_n;
                    gjatesia_letres_m = pika_ndarjes;
                    }
                else
                    {
                    shuma_katrore = (gjatesia_letres_m - pika_ndarjes) * gjatesia_letres_n;
                    gjatesia_letres_m = gjatesia_letres_m - pika_ndarjes;
                    } 
                    }
                else
                    {
                    if ((pika_ndarjes * gjatesia_letres_m) >
                        ((gjatesia_letres_n - pika_ndarjes) * gjatesia_letres_m))
                        {
                        shuma_katrore = pika_ndarjes * gjatesia_letres_m;
                        gjatesia_letres_n = pika_ndarjes;
                        }
                    else
                        {
                        shuma_katrore = (gjatesia_letres_n - pika_ndarjes) * gjatesia_letres_m;
                        gjatesia_letres_n = gjatesia_letres_n - pika_ndarjes;
                        } 
                }

            shkruaj(p + " fitoi katrorin me siperfaqe " + shuma_katrore.ToString() + "cm²",1); 
            string t1 = "   -> numrat_magjike ishin {"; 
            if (nr_magjike.Count > 0) 
            { 
                for (int i = 0; i < nr_magjike.Count; i++) 
                { 
                    if (i > 0) 
                        t1 += "," + nr_magjike[i]; 
                    else 
                        t1 += nr_magjike[i]; 
                } 
                t1 += "}"; 
                shkruaj(t1, 1); 
            } 
            else 
            {
            shkruaj("   -> ska numra magjike, sepse anet e letres jane te barabarta!  <----<< (:O)", 0); 
            } 
        } 
        static void merr_nr_magjike(int i, int j) 
        {
            int aMadhe, aVogel;
            if (i > j)
                {
                aMadhe = i;
                aVogel = j;
                }
            else
                {
                aMadhe = j;
                aVogel = i;
                }

            if (aVogel > 1) 
            {
                int iTemp = aVogel; 
                nr_magjike = new ArrayList();

                nr_magjike.Add(aVogel);
                for (int x = 1; x < aMadhe; x++) 
                {
                if ((2 * iTemp) + 1 < aMadhe) 
                    { 
                        iTemp = (2 * iTemp) + 1; 
                        nr_magjike.Add(iTemp); 
                    } 
                } 
            } 
        } 
        static void shkruaj(string p, int i) 
        { 
            Console.WriteLine(p); 
            if(i>0) 
            System.Threading.Thread.Sleep(500); 
        } 
    } 
} 



```

----------


## Urijan

po kompjuteri pret vetem ne nje ane pse te mos jete kjo e programuar qe kompjuteri te mundet te kapi numrat magjik te jete ai fitues te mundet ai te jet me i fort qe te mundi te gjihte lojtaret a do te mundet te behet kjo, nese lojtari gabon ne kapjen e numrave magjik ateher kompjuteri duhet ti kapi keto numra dhe ai fiton lojen, te jet nje loj si ne kazino qe nuk mundet te fitohet kompjuteri.

----------

