C# :: Aufgabe #174

3 Lösungen Lösungen öffentlich

Crowdfunding für Fibonacci-Uhr

Fortgeschrittener - C# von hollst - 24.04.2017 um 12:22 Uhr
Erneut FIBONACCI, jedoch diesmal in einem ganz anderen Zusammenhang.

Im Zuge von Crowdfunding ist in Kanada die sogenannte Fibonacci-Clock (Bild 1)
entwickelt und in die Produktion überführt worden.

(https://www.kickstarter.com/projects/basbrun/fibonacci-clock-an-open-source-clock-for-nerds-wit)

Es sollten für dieses Projekt innerhalb eines Monates (05 - 06/2015) 5.000 CAD
gesammelt werden (ca. 3.500 €), zusammengekommen sind aber sage und schreibe
(über) unglaubliche 125.000 €. Man lernt daraus, dass man mit einer guten (verrückten)
Idee manchmal auch einiges an Geld aquirieren kann.

Dabei ist an der Fibonacci-Clock nichts Kompliziertes dran. Im Grunde besteht sie
lediglich aus einem Display, das in fünf Quadrate mit unterschiedlicher
(variabler) Farbe und (fixer) Kantenlänge aufgeteilt ist.

Die Kantenlängen der Quadrate sind 1, 1, 2, 3 und 5, entsprechen also dem Beginn der
Fibonacci-Sequenz. Es lassen sich damit die Dezimalzahlen 0 ... 12 codieren.

Das Interessante an dem Display ist, dass man damit gleichzeitig
die Stunden und (teilweise) die Minuten darstellen kann. Dies geschieht mittels
wechselnder Farbcodierung der Quadrate und Aufaddition der den Quadraten zugeordnete
Fibonaccizahl. Die Farbe Rot steht für die Stunden, die Farbe Grün für die Minuten.
Wird ein Quadrat sowohl für die Stunden- als auch für die Minutensummation benötigt,
wird dies durch die Farbe Blau angezeigt (Bild 2). Weiß steht für "Nichtnutzung" des
Quadrates. Die Minutenzahl erhält man durch Multiplikation der Minutenzahlsumme mit 5,
somit ist die Genauigkeit der erfindungsgemäßen Uhr auf +- 2.5 Minuten begrenzt,
Vor- und Nachmittagszeiten sind identisch.

Mit den fünf Fibonaccizahlen lassen sich wie gesagt alle Werte von 0 bis 12 darstellen,
d. h. die Minutenanzeige "springt" lediglich alle fünf Minuten. Dies bedeutet allerdings nicht,
dass die Anzeige nicht schneller wechseln darf, denn es gibt mit den Ausnahmen für die
Null und die Zwölf für jede Zahl mehrere Möglichkeiten der Fibonacci-Codierung, die der
kanadische Erfinder auch in kurzen Intervallen und zufällig wechseln läßt.


Die Programmieraufgabe besteht darin, die Fibonacci-Clock mit einer Grafik-Applikation zu
simulieren. Der Minutenwechsel soll allerdings nicht im 5-Minuten-Takt, sondern sogar minütlich
erfolgen. Damit könnte man die Uhr vielleicht als Tester für Schnelldenker einsetzen.

Neben den vier Grundfarben des Erfinders (Weiß, Rot, Grün und Blau (Bild 3))werden also
vier weitere Farben zur Kodierung der fehlenden Additivzahlen 1, 2, 3 und 4 für den Minutenzähler
benötigt. Im Beispiel (Bild 4) sind es die Farben

Yellow (steht für Überlagerung mit Weiß),
Pink (steht für Überlagerung mit Rot),
Purple (steht für Überlagerung mit Grün) und
SkyBlue (steht für Überlagerung mit Blau)

Viel Erfolg!

Lösungen:

2 Kommentare
1x
vote_ok
von daniel59 (2860 Punkte) - 28.04.2017 um 15:16 Uhr
MainWindow.xaml.cs
Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Media;
using System.Windows.Threading;

namespace WpfFibonacciClock
{
    /// <summary>
    /// Interaktionslogik für MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        static readonly int[] fibonacci = { 1, 1, 2, 3, 5 };
        static readonly int[] indexes = { 0, 1, 2, 3, 4 };
        static readonly Dictionary<int, List<int[]>> Combinations = GetCombinations();
        static readonly Random rnd = new Random();

        static readonly BrushConverter bc = new BrushConverter();
        static readonly Brush Green = (Brush)bc.ConvertFromString("#00ff00");

        DispatcherTimer timer;
        public MainWindow()
        {
            InitializeComponent();

            DateTime dt = DateTime.Now;
            ChangeClock(dt);
            timer = new DispatcherTimer();
            timer.Interval = new TimeSpan(0, 0, 60);
            timer.Tick += Timer_Tick;
            timer.Start();
        }

        private void Timer_Tick(object sender, EventArgs e)
        {
            DateTime dt = DateTime.Now;
            ChangeClock(dt);
        }

        private void ChangeClock(DateTime dt)
        {
            int hour = dt.Hour % 12;
            int min5 = dt.Minute / 5;
            int min1 = dt.Minute % 5;

            int tempH = rnd.Next(0, Combinations[hour].Count);
            int tempM5 = rnd.Next(0, Combinations[min5].Count);
            int tempM1 = rnd.Next(0, Combinations[min1].Count);

            int[] fieldsHour = Combinations[hour][tempH];
            int[] fieldsMin5 = Combinations[min5][tempM5];
            int[] fieldsMin1 = Combinations[min1][tempM1];

            var off = indexes.Except(fieldsHour).Except(fieldsMin5);//weiß
            var onHM = fieldsHour.Intersect(fieldsMin5);//blau
            var onH = fieldsHour.Except(onHM);//rot
            var onM5 = fieldsMin5.Except(onHM);//grün

            foreach (int i in off)
            {
                if (!fieldsMin1.Contains(i) || min1 == 0)
                { SetColor(i,Brushes.White); }
                else
                { SetColor(i, Brushes.Yellow); }
            }
            foreach (int i in onHM)
            {
                if (!fieldsMin1.Contains(i) || min1 == 0)
                { SetColor(i, Brushes.Blue); }
                else
                { SetColor(i, Brushes.SkyBlue); }
            }
            foreach (int i in onM5)
            {
                if (!fieldsMin1.Contains(i) || min1 == 0)
                { SetColor(i, Green); }
                else
                { SetColor(i, Brushes.Purple); }
            }
            foreach (int i in onH)
            {
                if (!fieldsMin1.Contains(i) || min1 == 0)
                { SetColor(i, Brushes.Red); }
                else
                { SetColor(i, Brushes.Pink); }
            }


        }

        private void SetColor(int field, Brush color)
        {
            switch (field)
            {
                case 0:
                    rectanglef0.Fill = color;
                    break;

                case 1:
                    rectanglef1.Fill = color;
                    break;

                case 2:
                    rectanglef2.Fill = color;
                    break;

                case 3:
                    rectanglef3.Fill = color;
                    break;

                case 4:
                    rectanglef4.Fill = color;
                    break;
            }
        }

        private static Dictionary<int, List<int[]>> GetCombinations()
        {
            Dictionary<int, List<int[]>> result = new Dictionary<int, List<int[]>>();
            result.Add(0, new List<int[]>() { new int[0] });
            new OrderLoop<int>(indexes, delegate (int[] array)
            {
                for (int l = 1; l <= array.Length; l++)
                {
                    int sum = 0;
                    int[] idx = new int[l];
                    for (int i = 0; i < l; i++)
                    {
                        sum += fibonacci[array[i]];
                        idx[i] = array[i];
                    }
                    if (sum == 12)
                    { sum = 0; }

                    if (!result.ContainsKey(sum))
                    {
                        result.Add(sum, new List<int[]>());
                    }
                    Array.Sort(idx);
                    if (!result[sum].Any(a => a.SequenceEqual(idx)))
                    { result[sum].Add(idx); }

                }
                return LoopKey.Continue;
            });

            return result;
        }
    }
}


MainWindow.xaml
Quellcode ausblenden XML-Code
<Window x:Class="WpfFibonacciClock.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfFibonacciClock"
        mc:Ignorable="d"
        Title="MainWindow" Height="1000" Width="1600" AllowsTransparency="True" WindowStyle="None" Background="Transparent" WindowStartupLocation="CenterScreen">
    <Grid>
        <Canvas x:Name="canvasClock">
            <!--Kantenlänge 1-->
            <Rectangle x:Name="rectanglef0" Width="200" Height="200" Stroke="Black" Fill="#ff0000" Canvas.Top="200" Canvas.Left="400"/>
            <!--Kantenlänge 1-->
            <Rectangle x:Name="rectanglef1" Width="200" Height="200" Stroke="Black" Fill="#ffffff" Canvas.Top="0" Canvas.Left="400"/>
            <!--Kantenlänge 2-->
            <Rectangle x:Name="rectanglef2" Width="400" Height="400" Stroke="Black" Fill="#00ff00" Canvas.Top="0" Canvas.Left="0"/>
            <!--Kantenlänge 3-->
            <Rectangle x:Name="rectanglef3" Width="600" Height="600" Stroke="Black" Fill="#0000ff" Canvas.Top="400" Canvas.Left="0"/>
            <!--Kantenlänge 5-->
            <Rectangle x:Name="rectanglef4" Width="1000" Height="1000" Stroke="Black" Fill="#ff0000" Canvas.Top="0" Canvas.Left="600"/>
        </Canvas>
    </Grid>
</Window>


OrderLoop.cs
Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;
using System.Linq;

namespace WpfFibonacciClock
{
    public delegate T2 PFunc<in T1, out T2>(params T1[] parameter);
    public enum LoopKey { Break, Continue }
    public sealed class OrderLoop<T>
    {
        private int[] Indexes;
        private T[] Parameter;
        private int currentDepth = 1;
        private int continues = 1;

        private int count = 0;
        private T[] Source;
        private PFunc<T, LoopKey> Action;
        private bool breakUp = false;

        public OrderLoop(IEnumerable<T> source, PFunc<T, LoopKey> action)
        {
            Source = source.ToArray();
            Action = action;
            count = Source.Length;
            Parameter = new T[count];
            Indexes = new int[count];
            for (int i = 0; i < count; i++)
            { Indexes[i] = -1; }
            Invoke();
        }

        private void Invoke()
        {
            for (int i = 0; i < count && !breakUp; i++)
            {
                Parameter[currentDepth - 1] = Source[i];

                if (Indexes.Where(a => Array.IndexOf(Indexes, a) < currentDepth - 1).Contains(i))
                {
                    continue;
                }
                Indexes[currentDepth - 1] = i;
                if (currentDepth == count)
                {
                    LoopKey key = Action.Invoke(Parameter);
                    if (key == LoopKey.Break)
                    {
                        breakUp = true;
                        break;
                    }
                    else if ((int)key > 1)
                    {
                        continues = (int)key - 1;
                        if (continues < count)
                        {
                            goto DepthMinus;
                        }
                    }
                }
                else
                {
                    continues = ++currentDepth;
                    Invoke();
                    if (continues < currentDepth)
                    {
                        goto DepthMinus;
                    }
                }
            }
            DepthMinus:
            currentDepth--;
        }
    }
}


vote_ok
von hollst (6850 Punkte) - 02.05.2017 um 09:55 Uhr
Quellcode ausblenden C#-Code
using System;
using System.Text;
using System.Windows.Threading;
using System.Windows.Media;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace fibonacci_clock   {

    public partial class MainWindow : Window {
        string LZ = " ";

        bool bo_break = false, bo_break2 = false;
        bool bo_borders_copy_available = false;

        SolidColorBrush[] scb = new SolidColorBrush[]
            { Brushes.AntiqueWhite, Brushes.Red, Brushes.Green, Brushes.Blue,
                    Brushes.Yellow, Brushes.Pink, Brushes.Purple, Brushes.SkyBlue};

        System.Windows.Controls.Border[] borders_copy;

        public MainWindow() {

            InitializeComponent();
            run_dispatcherTimer();
            DispatcherTimer dispatcherTimer = new DispatcherTimer();
            dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
            dispatcherTimer.Interval = new TimeSpan(0, 0, 5);
            dispatcherTimer.Start();
        }

        Random rhm = new Random();

        private void run_dispatcherTimer(bool bo_real = true) {

            DateTime dt = DateTime.Now;

            int h12 = bo_real   ?   dt.Hour % 12    : rhm.Next(12);
            int m5  = bo_real   ?   dt.Minute / 5   : rhm.Next(12);
            int m1  = bo_real   ?   dt.Minute % 5   : rhm.Next(5);

            Fibo fbh = new Fibo(h12);
            Fibo fbm = new Fibo(m5);
            Fibo fbm1 = new Fibo(m1);

            if (bo_break) {                
                MessageBox.Show(dt.ToShortTimeString() + "   " + h12.ToString() +
                    LZ + (m5 * 5).ToString() + LZ + m1.ToString());
                bo_break = false;
            }

            byte[] c = new byte[fbh.fobos.Length];
            for (var i = 0; i < fbh.fobos.Length; i++) 
                c[i] = ((byte)(fbh.fobos[i] + 2 * fbm.fobos[i]));

            byte[] c_extend = new byte[fbh.fobos.Length];
            for (var i = 0; i < fbh.fobos.Length; i++)
                c_extend[i] = ((byte)(fbh.fobos[i] + 2 * fbm.fobos[i] + 4 * fbm1.fobos[i]));

            string titel_string = dt.ToLongTimeString();
            if (bo_break2)
                titel_string = " random simulation ";

          this.main_window.Title = "Fibonacci Clock   " + titel_string +
                LZ + h12.ToString() + LZ + (m5 * 5).ToString() + LZ + m1.ToString() + "    " +
                fbh.fobos.ToMyString() + fbm.fobos.ToMyString() + fbm1.fobos.ToMyString() +
                LZ + c.ToMyString() + c_extend.ToMyString();

            System.Windows.Controls.Border[] borders = new Border[]
                { this.border_1, this.border_2, this.border_3, this.border_4, this.border_5};

            if (!bo_borders_copy_available) {//beim ersten Mal

                borders_copy = new Border[borders.Length];
                for (var i = 0; i < borders_copy.Length; i++)
                    borders_copy[i] = borders[i];

                bo_borders_copy_available = true;
            }

            for (var i = 0; i < fbh.fobos.Length; i++)
                borders[i].Background = scb[c_extend[i]];
        }

        private void dispatcherTimer_Tick(object sender, EventArgs e) { 
            if(!bo_break && !bo_break2) run_dispatcherTimer();
        }

        private void border_1_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)                 
            { bo_break = !bo_break; run_dispatcherTimer(); }
        

        private int border_3_state = 0;

        private void border_3_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)        {
            //change window appearance
            border_3_state = (border_3_state + 1) % 2;

            if (border_3_state == 0)    {
                this.main_window.WindowState = WindowState.Normal;
                this.main_window.WindowStyle = WindowStyle.None;
                this.main_window.ResizeMode = ResizeMode.NoResize;
            }
            if (border_3_state == 1)    {//notwendig, um z. B. Uhr ausschalten zu können
                this.main_window.WindowState = WindowState.Normal;
                this.main_window.WindowStyle = WindowStyle.SingleBorderWindow;
                this.main_window.ResizeMode = ResizeMode.CanResize;
            }                       
        }

        int border_1_click_counter = 0;
        private void border_1_MouseDown(object sender, MouseButtonEventArgs e)        {
            //for visual checking the colour appearance
            border_1_click_counter = (border_1_click_counter + 1) % 2;
            int offset = 4;
            if (border_1_click_counter == 1)
                offset = 0;

            if (bo_borders_copy_available)
                for (var i = 0; i < 4; i++)
                    borders_copy[i].Background = scb[i + offset]; 
        }

        private void border_4_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)        {
            //change to simulation
            bo_break2 = !bo_break2;
            this.run_dispatcherTimer(false);
        }
    }

    public class Fibo    {

        static byte[] B5 = new byte[] { 1, 1, 2, 3, 5 };

        public byte[] fobos = new byte[B5.Length];

        Random r = new Random();

        public Fibo(int n)        {

            bool bo_okay = false;
            while(!bo_okay)            {
                int erg = 0;
                for(var i = 0; i < B5.Length; i++)  {
                    byte b = (byte)r.Next(2);
                    fobos[i] = b;
                    erg += b * B5[i];
                }
                bo_okay = erg == n;
            }
        }
    }

    public static class MyExtensions    {

        static public string ToMyString(this byte[] b)        {

            StringBuilder sb = new StringBuilder("[");
            for (var i = 0; i < b.Length; i++)
                sb.Append(b[i].ToString());
            return sb.ToString() + "]";
        }
    }
}


Quellcode ausblenden C#-Code
<Window x:Name="main_window" x:Class="fibonacci_clock.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:fibonacci_clock"
        mc:Ignorable="d"
        Title="fibonacci-clock" Height="300" Width="450" WindowStartupLocation="CenterScreen" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch" WindowStyle="None" ResizeMode="NoResize">
    <Grid x:Name="main_grid">
        <Grid.RowDefinitions>
            <RowDefinition Height="50*"/>
            <RowDefinition Height="50*"/>
            <RowDefinition Height="150*"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="100*"/>
            <ColumnDefinition Width="50*"/>
            <ColumnDefinition Width="250*"/>
        </Grid.ColumnDefinitions>
        <Border x:Name="border_5" BorderBrush="Black" BorderThickness="2,4,4,4" Grid.Column="2" Grid.RowSpan="3" Margin="0" MouseLeftButtonDown="border_1_MouseLeftButtonDown"/>
        <Border x:Name="border_4" BorderBrush="Black" BorderThickness="4,2,2,4" Grid.Row="2" Grid.ColumnSpan="2" MouseLeftButtonDown="border_4_MouseLeftButtonDown" />
        <Border x:Name="border_3" BorderBrush="Black" BorderThickness="4,4,2,2" Grid.RowSpan="2" MouseLeftButtonDown="border_3_MouseLeftButtonDown"/>
        <Border x:Name="border_1" BorderBrush="Black" BorderThickness="2" Grid.Column="1" Grid.Row="1" MouseDown="border_1_MouseDown"/>
        <Border x:Name="border_2" BorderBrush="Black" BorderThickness="2,4,2,2" Grid.Column="1" />
    </Grid>
</Window>
vote_ok
von gupta4Life (40 Punkte) - 15.06.2017 um 15:10 Uhr
Form1.cs
Quellcode ausblenden C#-Code
using System;
using System.Drawing;
using System.Windows.Forms;

namespace FibonacciClock {
    public partial class Form1 : Form {
        FibonacciTimer tmr;
        public Form1() {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e) {
            button1.BackColor = Color.White; button1.Text = "";
            button2.BackColor = Color.White; button2.Text = "";
            button3.BackColor = Color.White; button3.Text = "";
            button4.BackColor = Color.White; button4.Text = "";
            button5.BackColor = Color.White; button5.Text = "";

            tmr = new FibonacciTimer(new Button[] { button1, button2, button3, button4, button5 });
        }
    }
}

FibonacciTimer.cs
Quellcode ausblenden C#-Code
using System;
using System.Drawing;
using System.Windows.Forms;

namespace FibonacciClock {
    class FibonacciTimer {
        Timer clockTimer;
        bool[,] minuteAreas, hourAreas, addMinAreas;
        Button[] fibAreas;

        public FibonacciTimer(Button[] buttons) {
            fibAreas = new Button[5];
            Array.Copy(buttons, fibAreas, 5);
            clockTimer = new Timer();
            clockTimer.Interval = 60000;
            clockTimer.Tick += new EventHandler(OnClockTimer);
            OnClockTimer(clockTimer, null);
            clockTimer.Start();
        }

        void OnClockTimer(object sender, EventArgs args) {

            int min = DateTime.Now.Minute; //green
            int hour = DateTime.Now.Hour; //red
            // minutes only +-2.5 accuracy
            minuteAreas = GetColors(min / 5);
            // hours up to 0-11
            hourAreas = GetColors(hour % 12);
            //additional minutes
            int addMin = min - (min / 5) * 5;//pink, purple ect.
            addMinAreas = GetColors(addMin);
            // if more possibilities for hour, minute and additional minutes 
            // configuration exist, switch between them randomly
            Random rnd = new Random();
            SetColors(minuteAreas, rnd.Next(0, minuteAreas.GetLength(0) - 1),
                        hourAreas, rnd.Next(0, hourAreas.GetLength(0) - 1),
                        addMinAreas, rnd.Next(0, addMinAreas.GetLength(0) - 1));
    }

        bool[,] GetColors(int time) {
        // false -> white, true -> color 
        //array represents buttons {1,2,3,4,5}
        switch (time) {
            case 0:
                return new bool[1, 5] { { false, false, false, false, false } };
            case 1:
                return new bool[2, 5] { { true, false, false, false, false }, { false, true, true, true, true } };
            case 2:
                return new bool[2, 5] { { true, true, false, false, false }, { false, false, true, false, false } };
            case 3:
                return new bool[3, 5] { { true, false, true, false, false }, { false, true, true, false, false },
                                            { false, false, false, true, false }};
            case 4:
                return new bool[3, 5] { { true, true, true, false, false }, { true, false, false, true, false },
                                            { false, true, false, true, false }};
            case 5:
                return new bool[3, 5] { { true, true, false, true, false }, { false, false, true, true, false },
                                            { false, false, false, false, true}};
            case 6:
                return new bool[5, 5] { { true, false, false, false, true}, { true, false, true, true, false },
                                            { false, true, true, true, false }, { true, false, false, false, true},
                                            { false, true, false, false, true}};
            case 7:
                return new bool[3, 5] { { true, true, true, true, false }, { true, true, false, false, true},
                                            { false, false, true, false, true }};
            case 8:
                return new bool[3, 5] { { true, false, true, false, true}, { false, true, true, false, true},
                                            { false, false, false, true, true }};
            case 9:
                return new bool[3, 5] { { true, true, true, false, true}, { true, false, true, false, true},
                                            { false, true, false, true, true }};
            case 10:
                return new bool[2, 5] { { true, true, false, true, true }, { false, false, true, true, true } };
            case 11:
                return new bool[2, 5] { { true, false, true, true, true }, { false, true, true, true, true } };
            default:
                goto case 0;
        }
    }
        void SetColors(bool[,] minA, int rndMind, bool[,] hA, int rndHind, bool[,] adMinA, int rndAdMind) {
        for (int i = 0; i < 5; i++) {
            if (minA[rndMind, i] && hA[rndHind, i] && adMinA[rndAdMind, i])
                fibAreas[i].BackColor = Color.SkyBlue;
            else if (minA[rndMind, i] && hA[rndHind, i] && !adMinA[rndAdMind, i])
                fibAreas[i].BackColor = Color.Blue;
            else if (!minA[rndMind, i] && hA[rndHind, i] && adMinA[rndAdMind, i])
                fibAreas[i].BackColor = Color.Pink;
            else if (!minA[rndMind, i] && hA[rndHind, i] && !adMinA[rndAdMind, i])
                fibAreas[i].BackColor = Color.Red;
            else if (minA[rndMind, i] && !hA[rndHind, i] && adMinA[rndAdMind, i])
                fibAreas[i].BackColor = Color.Purple;
            else if (minA[rndMind, i] && !hA[rndHind, i] && !adMinA[rndAdMind, i])
                fibAreas[i].BackColor = Color.Green;
            else if (!minA[rndMind, i] && !hA[rndHind, i] && adMinA[rndAdMind, i])
                fibAreas[i].BackColor = Color.Yellow;
            else
                fibAreas[i].BackColor = Color.White;
        }
    }
}