How to Spawn an Object in between Randomly Spawned Objects with no Overlapping?

Hello,

I am trying to spawn multiple clones of one object and make its position between a number of randomly spawned objects. In other words, let's say we have many clones of the square objects in different colors, and they are all randomly spawned in one line without overlapping. The square objects are spawned perfectly for me, and what I need to do additionally is to spawn two clones of a circle object and position the circle clones in between the square objects and without overlapping. As displayed in the picture below:

This is the script I am using to spawn the random squares, and I also added a part where I tried to spawn the circles but it didn't work with me as the circles totally overlapped with the squares.

 using UnityEngine;
 using System;
 using System.Collections;
 using System.Collections.Generic;         //Allows us to use Lists.
 using Random = UnityEngine.Random;         //Tells Random to use the Unity Engine random number generator.
 
 namespace Completed
     
 {
     
     public class BoardManager : MonoBehaviour
     {
         
         // Using Serializable allows us to embed a class with sub properties in the inspector.
         [Serializable]
         public class Count
         {
             public int minimum;             //Minimum value for our Count class.
             public int maximum;             //Maximum value for our Count class.
             
 
             //Assignment constructor.
             public Count (int min, int max)
             {
                 minimum = min;
                 maximum = max;
             }
         }
         
         
         public int columns = 9; 
         public Count redSquareCount = new Count (1, 2); //Lower and upper limit for our random number of squares per level.
         public Count greenSquareCount = new Count (1, 1);
         public Count purpleSquareCount = new Count (1, 1);
         public Count creamCupboardCount = new Count (1, 1);
         public Count circleCount = new Count (2, 2);
         public GameObject[] redSquares;    //Array of floor prefabs.
         public GameObject[] greenSquares;
         public GameObject[] purpleSquares;
         public GameObject[] circles;
         
                             
         private List <Vector3> gridPositions = new List <Vector3> ();
         
 
         void InitialiseList ()
         {
             //Clear our list gridPositions.
             gridPositions.Clear ();
             
             //Loop through x axis (columns).
             for(int x = 2; x < columns; x++)
             {
 
                 //At each index add a new Vector3 to our list with the x coordinate of that position.
                 gridPositions.Add (new Vector3(x, 0.3f, 0f));
             }    
 
         }
         
 
         //RandomPosition returns a random position from our list gridPositions.
         Vector3 RandomPosition ()
         {
             //Declare an integer randomIndex, set it's value to a random number between 0 and the count of items in our List gridPositions.
             int randomIndex = Random.Range (0, gridPositions.Count);
             
             //Declare a variable of type Vector3 called randomPosition, set it's value to the entry at randomIndex from our List gridPositions.
             Vector3 randomPosition = gridPositions[randomIndex];
             
             
             //Remove the entry at randomIndex from the list so that it can't be re-used.
             gridPositions.RemoveAt (randomIndex);
             
             
             //Return the randomly selected Vector3 position.
             return randomPosition;    
         }
 
         
         //LayoutObjectAtRandom accepts an array of game objects to choose from along with a minimum and maximum range for the number of objects to create.
         void LayoutObjectAtRandom (GameObject[] tileArray, int minimum, int maximum)
         {
             //Choose a random number of objects to instantiate within the minimum and maximum limits
             int objectCount = Random.Range (minimum, maximum+1);
             
             //Instantiate objects until the randomly chosen limit objectCount is reached
             for(int i = 0; i < objectCount; i++)
             {
                 
                 //Choose a position for randomPosition by getting a random position from our list of available Vector3s stored in gridPosition
                 Vector3 randomPosition = RandomPosition();
                 
             
 
                 //Choose a random tile from tileArray and assign it to tileChoice
                 GameObject tileChoice = tileArray[Random.Range (0, tileArray.Length)];
                 Vector3 size = tileChoice.GetComponent<Renderer>().bounds.size;
 
                 randomPosition += new Vector3(randomPosition.x * size.x, randomPosition.y * size.y, randomPosition.z * size.z);
 
                 
                 //Instantiate tileChoice at the position returned by RandomPosition with no change in rotation
                 Instantiate(tileChoice, randomPosition, Quaternion.identity);
 
             }    
 
         }
 
         
         
         //SetupScene initializes our level and calls the previous functions to lay out the game board
         public void SetupScene (int level)
         {
 
             //Reset our list of gridpositions.
             InitialiseList ();
             
             //Instantiate a random number of object tiles based on minimum and maximum, at randomized positions.
             LayoutObjectAtRandom (redSquares, redSquareCount.minimum, redSquareCount.maximum);
             LayoutObjectAtRandom (greenSquares, greenSquareCount.minimum, greenSquareCount.maximum);
             LayoutObjectAtRandom (purpleSquares, purpleSquareCount.minimum, purpleSquareCount.maximum);
             LayoutObjectAtRandom (circles, circleCount.minimum, circleCount.maximum);
           
         }
 
 
     }
 }