Proste zadanie z tablicami

Treść zadania
Utwórz tablice dwuwymiarową, w której liczba komórek w kolejnych wierszach będzie równa dziesięciu kolejnym ciągom Fibonacciego, poczynając od elementu o wartości 1 (1, 1, 2, 3, 5 itd.).

Wartość każdej komórki powinna być jej numerem w danym wierszu w kolejności malejącej (czyli dla wiersza o długości 5 komórek, kolejne wartości to 5, 4, 3, 2, 1). Zawartość tablicy wyświetl na ekranie.

Pomożecie mi to rozwiązać? Nie bardzo wiem jak się do tego zabrać, ja bym to zrobił z jagged array, ale w zadaniu wymagają tablicy dwuwymiarowej.

A co już masz i jakiej pomocy oczekujesz ?

greg_vv napisał(a):

Nie bardzo wiem jak się do tego zabrać, ja bym to zrobił z jagged array, ale w zadaniu wymagają tablicy dwuwymiarowej.

Też bym nie wiedział, treść tego zadania stoi w sprzeczności sama ze sobą. Może autor zadania nie odróżnia tych dwóch rodzajów tablic?

Zrób tablicę tablic i będzie ok. tzw. tablicę postrzępioną i nie przejmuj się takim bzdurami .

Utwórz tablice dwuwymiarową, w której liczba komórek w kolejnych wierszach będzie równa dziesięciu kolejnym ciągom Fibonacciego

"kolejnym wartościom ciągu fibonacciego", bo ciąg chyba mamy jeden? Ale nawet jeśli to część zadania przed przecinkiem stoi w sprzeczności z częścią zdania po przecinku?

Ja myślę, że to będzie chyba tak:

using System;

namespace FibonacciHomeWork
{
    class Program
    {
        static void Main()
        {
            int[] fibonacci = new int[10];
            fibonacci[0] = 1;
            fibonacci[1] = 1;
            for(int i=2; i < fibonacci.Length; i++)
            {
                fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
            }
            Console.WriteLine("Ciąg fibonacciego:");
            for (int i = 0; i < fibonacci.Length; i++)
            {
                Console.Write(fibonacci[i] + " ");
            }
            Console.WriteLine();

            int[][] OurMatrix = new int[10][];
            for(int i = 0; i < OurMatrix.GetLength(0); i++)
            {
                OurMatrix[i] = new int[fibonacci[i]];
            }

            
            for (int i = 0; i < OurMatrix.GetLength(0); i++)
            {
                int wartość = OurMatrix[i].Length;
                for (int j = 0; j < OurMatrix[i].Length; j++)
                {
                    OurMatrix[i][j] = wartość;
                    wartość--;
                }
            }


            Console.WriteLine("Nasza tablica:");
            for (int i = 0; i < OurMatrix.GetLength(0); i++)
            {
                for (int j = 0; j < OurMatrix[i].Length; j++)
                {
                    Console.Write(OurMatrix[i][j] + " ");                    
                }
                Console.WriteLine();
            }


            Console.ReadKey();
        }
    }
}

Ale po co tu tyle tablic pośredniczących i obliczeń. Wartość poprzedniego elementu ciągu mamy jako długość poprzednich tablic, więc nie trzeba jej oddzielnie przechowywać. Obliczanie wartości komórki też można zrobić prościej. W ogóle potrzebne są dwie pętle - zewnętrzna tworząca tablice w tablicy i wewnętrzna wypełniająca tablice wartościami.
To jest w końcu proste zadanie, więcej niż 10 linijek kodu wygląda dziwnie.

somekind napisał(a):

Ale po co tu tyle tablic pośredniczących i obliczeń. Wartość poprzedniego elementu ciągu mamy jako długość poprzednich tablic, więc nie trzeba jej oddzielnie przechowywać. Obliczanie wartości komórki też można zrobić prościej. W ogóle potrzebne są dwie pętle - zewnętrzna tworząca tablice w tablicy i wewnętrzna wypełniająca tablice wartościami.
To jest w końcu proste zadanie, więcej niż 10 linijek kodu wygląda dziwnie.

Faktycznie. można to trochę zoptymalizować. Usuwając wszystko to co zbędne (włącznie z wyświetlaniem), wyjdzie nam to:

using System;

namespace FibonacciHomeWork
{
    class Program
    {
        static void Main()
        {
            int[] fibonacci = new int[10];
            fibonacci[0] = 1;
            fibonacci[1] = 1;
            for (int i = 2; i < fibonacci.Length; i++)
            {
                fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
            }

            int[][] OurMatrix = new int[10][];
            for (int i = 0; i < OurMatrix.GetLength(0); i++)
            {
                OurMatrix[i] = new int[fibonacci[i]];
                int wartość = OurMatrix[i].Length;
                for (int j = 0; j < fibonacci[i]; j++)
                {
                    OurMatrix[i][j] = wartość;
                    wartość--;
                }
            }

            Console.ReadKey();
        }
    }
}

To wtedy zmniejszymy ilość zmiennych zadeklarowanych, ale długość kodu pozostanie taka sama. Dużo to zmieni?

using System;

namespace FibonacciHomeWork
{
    class Program
    {
        static void Main()
        {
            int[][] OurMatrix = new int[10][];
            
            
            for (int i = 0; i < OurMatrix.GetLength(0); i++)
            {
                if (i == 0)
                {
                    OurMatrix[0] = new int[1];
                }
                else if (i == 1)
                {
                    OurMatrix[1] = new int[1];
                }
                else
                {
                    OurMatrix[i] = new int[OurMatrix[i - 1].Length + OurMatrix[i - 2].Length];
                }
                for (int j = 0; j < OurMatrix[i].Length; j++)
                {
                    OurMatrix[i][j] = OurMatrix[i].Length-j;
                }
            }

            Console.ReadKey();
        }
    }
}