Today, we will explore how to solve a simple algorithm problem using Kotlin.
The topic is “Making Cocktails.” This problem helps us learn efficient algorithm design and implementation
by combining various ingredients to create the desired cocktail.
After understanding the basic concept of the problem, we can write the code and conduct tests to
familiarize ourselves with several important elements in actual coding tests.
Problem Description
We are now bartenders at a cocktail bar. The customer has requested a specific color, and we need to
create a cocktail that matches that color using various ingredients.
The following input is given:
- The number of ingredients N (1 <= N <= 100)
- An array of colors representing each ingredient (colors are provided as strings)
- The color requested by the customer targetColor (string)
We need to determine whether we can make a cocktail of the requested color.
If it can be made, we should output “Possible”; otherwise, we output “Impossible.”
Input Example
5
"red", "blue", "green", "yellow", "red"
"purple"
Output Example
Possible
Algorithm Design
To solve this problem, we need to perform a few simple operations.
First, we must check all the given colors to see if any match the customer’s request.
We can approach it as follows:
- Search the array of colors to see if it contains a color that matches the customer’s request.
- If a matching color is found, print “Possible” and terminate the iteration.
- If no matching color is found after checking all colors, print “Impossible.”
Code Writing
Now, let’s write Kotlin code based on the algorithm designed above.
Using Kotlin’s concise syntax, we can implement the solution to the problem as follows.
fun canMakeCocktail(colors: Array, targetColor: String): String {
for (color in colors) {
if (color == targetColor) {
return "Possible"
}
}
return "Impossible"
}
fun main() {
val colors = arrayOf("red", "blue", "green", "yellow", "red")
val targetColor = "purple"
println(canMakeCocktail(colors, targetColor))
}
Code Explanation
In the code above, the canMakeCocktail function takes two parameters.
The first parameter is an array of colors, and the second parameter is the color requested by the customer.
It uses a for loop to iterate through the array, checking for a match with the requested color.
If a matching color is found, it returns “Possible” and terminates.
If no matches are found after checking all colors, it returns “Impossible.”
The main function sets the given array of colors and the requested color,
and calls the canMakeCocktail function to output the result.
Test Cases
Now, let’s test the code. We will check our code’s correctness through various input scenarios.
1. Typical case
Input: ["red", "blue", "green", "yellow", "red"], "green"
Output: Possible
2. Case where requested color does not exist
Input: ["red", "blue", "green", "yellow", "red"], "orange"
Output: Impossible
3. Case with duplicate colors
Input: ["red", "blue", "blue", "yellow", "red"], "blue"
Output: Possible
4. Case where all colors are the same
Input: ["red", "red", "red", "red", "red"], "red"
Output: Possible
5. Case where color array is empty
Input: [], "red"
Output: Impossible
Result Analysis
All test cases produced the expected results.
This confirms that the written code meets the requirements and operates
as an algorithm that considers various scenarios.
Conclusion
In this lesson, we learned how to solve a simple algorithm problem using Kotlin.
Through the cocktail-making problem, we explored array searching, conditional statements, and function definitions.
When solving algorithm problems, it is essential to clearly understand the problem requirements and to select
appropriate data structures and algorithms accordingly.
I hope you all continue to enhance your algorithm skills through various problems.
Next time, I will return with a more complex problem.
Thank you!