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;
        }
    }
}

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>

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--;
        }
    }
}