Array Manipulations: Simulating a Balloon Sharing Game in C#

Introduction

Welcome! Are you ready to embark on a captivating journey into the world of array manipulations? Today, we're going to explore a fascinating scenario involving a wonderful small town, its houses, and a fun balloon game. Without further ado, let's dive right in!

Task Statement

Picture a quaint, small town where every house is numbered sequentially from 1 to n . One day, a festive town event is held, and balloons are tied to each house. The festivities do not end there. At the conclusion of the event, a fun game is played: at each step of the game, each house sends half of its balloons to the neighboring house simultaneously (the neighbor on the right side, and for the last house, the neighbor is the first house). The game goes on until, at some step, there are no changes in the number of balloons compared to the previous step. The task is to create a C# method, Solution(List<int> balloons), where balloons is a List<int> representing the number of balloons at each house. The method should simulate this game and return the number of steps in the game. For example, if balloons = new List<int>{4, 1, 2}, the output should be 3 . After the first step, the list becomes {3, 3, 1} . This is because the first house sends 2 balloons and gets 1, the second house sends nothing but gets 2, and the third house sends 1 but receives nothing. Note that when the number of balloons x is odd, then the house sends (x - 1) / 2 balloons. After the second step, the list becomes {2, 3, 2} and never changes after that. So, after the third step, the process finishes.

Solution Building: Step 1 - Understanding the Problem

Firstly, it's essential to note that we're dealing with a cyclical event. In other words, when iterating over our balloons array, we need to perceive the array as circular, meaning balloons[n - 1] should refer back to balloons[0] . This concept of cyclicity becomes crucial when we consider the last house passing balloons to the first.

Solution Building: Step 2 - Setting Up The Loop

Confident in our understanding of the problem, we move on to programming our solution. First, we need to set up a loop to iterate through the rounds of the balloon sharing. This loop should continue as long as the list changes. C# using System; using System.Collections.Generic; class BalloonGame {public static int Solution(List<int> balloons) {int steps = 0; while (true) {steps++; List<int> newBalloons = new List<int>(balloons); // Store updated balloon counts // TODO: Share the balloons if (newBalloons.SequenceEqual(balloons)) {break;} balloons = new List<int>(newBalloons); // Update balloons with new counts.} return steps;}}

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Solution Building: Step 3 - Sharing Balloons

Our next step delves into the core game mechanics: sharing the balloons. Throughout each cycle, each house must share half of its balloons with the next house.

We must also ensure that the last house shares balloons with the first house at the end of each cycle — for this, we'll use the handy modulo operator.

Here's the updated solution, complete with the mechanics of balloon sharing:

using System;
using System.Collections.Generic;
using System.Linq;

class BalloonGame
{
    public static int Solution(List<int> balloons)
    {
        int n = balloons.Count;
        int steps = 0;
        while (true)
        {
            steps++;
            List<int> newBalloons = new List<int>(balloons);
            for (int i = 0; i < n; i++)
            {
                int share = balloons[i] / 2;  // Balloons to share
                newBalloons[i] -= share;  // Decrease balloons of current house.
                newBalloons[(i + 1) % n] += share;  // Increase balloons of next house.
            }
            if (newBalloons.SequenceEqual(balloons))
            {
                break;
            }
            balloons = new List<int>(newBalloons);
        }
        return steps;
    }
    
    static void Main()
    {
        List<int> balloons = new List<int> { 4, 1, 2 };
        Console.WriteLine(Solution(balloons));  // Should output 3
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

class BalloonGame
{
    public static int Solution(List<int> balloons)
    {
        int n = balloons.Count;
        int steps = 0;
        while (true)
        {
            steps++;
            List<int> newBalloons = new List<int>(balloons);
            for (int i = 0; i < n; i++)
            {
                int share = balloons[i] / 2;  // Balloons to share
                newBalloons[i] -= share;  // Decrease balloons of current house.
                newBalloons[(i + 1) % n] += share;  // Increase balloons of next house.
            }
            if (newBalloons.SequenceEqual(balloons))
            {
                break;
            }
            balloons = new List<int>(newBalloons);
        }
        return steps;
    }
    
    static void Main()
    {
        List<int> balloons = new List<int> { 4, 1, 2 };
        Console.WriteLine(Solution(balloons));  // Should output 3
    }
}

Bravo! We've navigated through the maze of array manipulation and successfully simulated an intriguing game event.