Mastering Go Slices: Subsetting and Manipulation

Go slices are a powerful and flexible data structure, offering efficient ways to work with sequences of data. This challenge will test your understanding of slice operations, including creating sub-slices, modifying elements, and appending new elements. Successfully completing this challenge demonstrates proficiency in a core aspect of Go programming.

Problem Description

You are tasked with creating a Go program that performs various slice operations based on user-provided instructions. The program should accept a slice of integers as input and then execute a series of commands to manipulate it. The commands will be strings representing slice operations, and your program must correctly interpret and execute these commands.

Specifically, the program should handle the following commands:

1. subset [start] [end]: Creates a sub-slice from the original slice, starting at index start (inclusive) and ending at index end (exclusive). The result should be a new slice.
2. append [value]: Appends the integer value to the end of the slice. The result should be a new slice.
3. insert [index] [value]: Inserts the integer value at the specified index in the slice. Existing elements from that index onwards should be shifted to the right. The result should be a new slice.
4. delete [index]: Deletes the element at the specified index from the slice. Elements to the right of the deleted element should be shifted to the left. The result should be a new slice.
5. print: Prints the current state of the slice to the console.

The program should continuously accept commands until the input ends (e.g., an empty line or a specific termination command, which is not required for this challenge). After each command execution, the slice should be updated, and the next command should be processed.

Examples

Example 1:

Input:
[1, 2, 3, 4, 5]
subset 1 3
append 6
print

Output:

[1 2 3]
[1 2 3 6]

Explanation: The first command creates a sub-slice from index 1 to 3 (exclusive), resulting in [1 2 3]. The second command appends 6 to the end, resulting in [1 2 3 6]. The print command displays the current slice.

Example 2:

Input:
[10, 20, 30, 40, 50]
insert 2 25
delete 1
print

Output:

[10 25 20 30 40 50]
[10 25 30 40 50]

Explanation: The insert command inserts 25 at index 2, shifting the existing elements to the right, resulting in [10 25 20 30 40 50]. The delete command deletes the element at index 1, shifting the remaining elements to the left, resulting in [10 25 30 40 50]. The print command displays the current slice.

Example 3:

Input:
[1, 2, 3]
subset 0 1
append 4
delete 2
print

Output:

[1]
[1 4]
[1]

Explanation: The first subset creates [1]. The append adds 4, resulting in [1 4]. The delete removes the element at index 2 (which is out of bounds, so nothing happens), leaving [1].

Constraints

• The initial slice will contain between 0 and 100 integers.
• start and end indices for subset will be non-negative integers. start will be less than or equal to end. Both will be less than or equal to the length of the slice.
• index for insert and delete will be non-negative integers and less than or equal to the length of the slice after the previous operation.
• value for append and insert will be an integer.
• The program should handle edge cases gracefully, such as attempting to access indices outside the slice bounds (e.g., in delete or subset). In such cases, the operation should be effectively a no-op (no change to the slice).
• The program should be reasonably efficient. Avoid unnecessary memory allocations.

Notes

• Remember that slices are backed by arrays. Modifying a slice can potentially modify the underlying array, which can affect other slices that share the same array.
• Consider using the built-in append function for efficient slice appending.
• When inserting or deleting elements, be mindful of how you shift the remaining elements to maintain the correct order.
• The input format is crucial. Ensure your program correctly parses the commands and their arguments.
• Error handling is not explicitly required, but graceful handling of invalid input (e.g., non-integer values where integers are expected) is encouraged.