0

I'm creating my first game and ran into some problems. I always have 7 tiles and I need to make all the possible combinations(max 5040) File example: 13 01 02 24 14 12 25 the numbers means how many numbers on every side like 13 one tile side has 1 dot the other one has 3 dots. The result example:

31 10 02 24 41 12 25     
52 21 14 42 20 01 13      
31 12 24 41 10 02 25     
52 20 01 14 42 21 13      
...

How do I do that? I tried using recursion but didn't work This is what I have:

    class Kauliukas
{
    public int Dalis1 { get; set; }
    public int Dalis2 { get; set; }

    public Kauliukas(int dalis1, int dalis2)
    {
        Dalis1 = dalis1;
        Dalis2 = dalis2;
    }

    public Kauliukas()
    {

    }

}

class KauliukuKonteineris
{
    public const int MaxIlgis = 7;
    private Kauliukas[] Kauliukai = new Kauliukas[MaxIlgis];
    public int Count { get; set; }

    public KauliukuKonteineris(int size)
    {
        Kauliukai = new Kauliukas[size];
    }
    public void Add(Kauliukas kauliukas)
    {
        Kauliukai[Count++] = kauliukas;
    }
    public Kauliukas Get(int index)
    {
        return Kauliukai[index];
    }

}

class Grandine
{
    public static int MaxIlgis = 7;
    private Kauliukas[] Kauliukai = new Kauliukas[MaxIlgis];
    public int Count { get; set; }

    public Grandine(int size)
    {
        Kauliukai = new Kauliukas[size];
    }
    public void Add(Kauliukas kauliukas)
    {
        Kauliukai[Count++] = kauliukas;
    }
    public Kauliukas Get(int index)
    {
        return Kauliukai[index];
    }
}

class GrandiniuKonteineris
{
    public const int MaxGrandines = 5040;
    private Grandine[] Grandines = new Grandine[MaxGrandines];
    public int Count { get; set; }

    public GrandiniuKonteineris(int size)
    {
        Grandines = new Grandine[size];
    }
    public void Add(Grandine grandine)
    {
        Grandines[Count++] = grandine;
    }
    public Grandine Get(int index)
    {
        return Grandines[index];
    }
}

class Program
{
    public const int MaxKauliuku = 7;
    public const string DataFile = "Kur3.txt";
    public const int MaxGrandiniu = 5040;
    static void Main(string[] args)
    {

        KauliukuKonteineris Duomenys = new KauliukuKonteineris(MaxKauliuku);
        Skaitymas(Duomenys);
        GrandiniuKonteineris Rezultatai = new GrandiniuKonteineris(MaxGrandiniu);
        GrandiniuSudarymas(Duomenys, Rezultatai);
    }

    /// <summary>
    /// Duomenu nuskaitymas is failo ir sukelimas i konteinerine klase
    /// </summary>
    /// <param name="Duomenys"></param>
    public static void Skaitymas(KauliukuKonteineris Duomenys)
    {
        using (StreamReader reader = new StreamReader(DataFile))
        {
            string line = reader.ReadLine(); // Nuskaitoma visa eilute
            string[] values = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); // Padalina skaicius
            for(int i=0; i<values.Length; i++)
            {
                int dalis1 = int.Parse(values[i]) / 10; // Dvizenkli skaciu padalinus is 10 gaunamas skaitmuo esantis pirmoje pozicijoje
                int dalis2 = int.Parse(values[i]) % 10; // Dvizenklio skaiciaus padalinto is 10 liekana - skaitmuo antroje pozicijoje
                Kauliukas kauliukas = new Kauliukas(dalis1, dalis2);
                Duomenys.Add(kauliukas);
            }
        }
    }
Psi
  • 6,387
  • 3
  • 16
  • 26

1 Answers1

0

In fact, 31 10 02 24 41 12 25 would be the same as 3 1 0 2 4 1 2 5, you have 7 tiles, but they can only have 8 distinct values because the values must match at their sides.

So maybe that leads you to the right way. At the end, you will have way more than 5040 combinations: 8 numbers with 7 different values = 7^8 = 5,764,801 different combinations. That is true if you allow duplicate tiles. If not, it's shown in the other answer how many combinations you would get.

However, in either case, I would not suggest trying to keep them in memory.

Psi
  • 6,387
  • 3
  • 16
  • 26