# 5 Best Ways to Split an Array and Append the First Part to the End in Python

π‘ Problem Formulation: Imagine needing to perform an operation on an array where you split it at a certain point and then append the first part to the end. For example, given an array `[1, 2, 3, 4, 5]` and a split position of 3, the desired output would be `[4, 5, 1, 2, 3]`. This article explores different Python methods to achieve this array manipulation.

## Method 1: Using Slicing

Slicing in Python allows you to create a new list by specifying the part of the original list that you want to copy. Method 1 uses slicing to separate the array into two parts at the given index and then concatenate the second part in front of the first.

Here’s an example:

```def rotate_list(arr, n):
return arr[n:] + arr[:n]

example_list = [1, 2, 3, 4, 5]
rotated_list = rotate_list(example_list, 3)
print(rotated_list)```

Output:

`[4, 5, 1, 2, 3]`

This method involves defining a function `rotate_list` that takes an array and an integer n. It then returns a new list by concatenating two slices: the sub-array from index n to the end and the sub-array from the beginning up to index n.

## Method 2: Using Collections Module

Python’s collections module provides a `deque` object that has an optimized method for rotations. Method 2 uses deque to rotate the array by converting the list to a deque, rotating it, and then converting it back to a list.

Here’s an example:

```from collections import deque

def rotate_list(arr, n):
d = deque(arr)
d.rotate(-n)
return list(d)

example_list = [1, 2, 3, 4, 5]
rotated_list = rotate_list(example_list, 3)
print(rotated_list)```

Output:

`[4, 5, 1, 2, 3]`

In this approach, the array is first converted to a `deque`, which is then rotated leftward by n positions using the `rotate()` method. The negative sign indicates a left rotation. The rotated deque is then converted back into a list.

## Method 3: Using Pop and Insert

Method 3 utilizes a combination of the `pop()` and `insert()` methods to remove elements from the front of the list and then insert them at the end. This is repeated for n number of times to achieve the desired rotation.

Here’s an example:

```def rotate_list(arr, n):
for i in range(n):
arr.append(arr.pop(0))
return arr

example_list = [1, 2, 3, 4, 5]
rotated_list = rotate_list(example_list, 3)
print(rotated_list)```

Output:

`[4, 5, 1, 2, 3]`

This code snippet manually simulates the rotation by repeatedly popping the first element and appending it to the end of the list using a loop that runs n times.

## Method 4: Using NumPy

For arrays of numeric types, the NumPy library can provide an efficient way to rotate arrays. Method 4 uses the capabilities of NumPy to perform a similar slicing operation.

Here’s an example:

```import numpy as np

def rotate_list(arr, n):
arr_np = np.array(arr)
return np.concatenate((arr_np[n:], arr_np[:n]))

example_list = [1, 2, 3, 4, 5]
rotated_list = rotate_list(example_list, 3)
print(rotated_list)```

Output:

`[4 5 1 2 3]`

The `np.array` function is used to convert the list to a NumPy array. Slicing is then performed on the NumPy array to split and concatenate the parts, leveraging NumPy’s optimized performance.

## Bonus One-Liner Method 5: Using List Comprehension and Modulo

A one-liner using list comprehension can accomplish the rotation by computing the new index for each element with the modulo operator. This method does not use any additional data structures or libraries.

Here’s an example:

```example_list = [1, 2, 3, 4, 5]
n = 3
rotated_list = [example_list[(i + n) % len(example_list)] for i in range(len(example_list))]
print(rotated_list)```

Output:

`[4, 5, 1, 2, 3]`

This one-liner rotates the list by calculating the new index for each element using the modulo operation within a list comprehension. This creates a new list in the desired order.

## Summary/Discussion

• Method 1: Slicing. Simple and readable. Performance may degrade with large lists.
• Method 2: Collections Module. Optimized for rotations. Requires importing an additional module.
• Method 3: Pop and Insert. Straightforward, but not very efficient due to the repetitive pop and insert operations.
• Method 4: Using NumPy. Efficient for numeric data. Requires the NumPy library which may not be available in all environments.
• Method 5: One-Liner with Modulo. Concise and elegant, and does not rely on any external libraries.