Arrays

## Declaring and Initializing Arrays

In Go, you can declare an array using the `var` keyword followed by the array name, size, and element type. For example:

```go
var arr [5]int
```

This declares an array named `arr` with a size of 5 and elements of type `int`.

You can also initialize an array with values during declaration:

```go
arr := [5]int{1, 2, 3, 4, 5}
```

Or let the compiler infer the size:

```go
arr := [...]int{1, 2, 3, 4, 5}
```

## Accessing Array Elements

You can access array elements using the index operator `[]`. Array indices start at 0, so the first element is accessed with `arr`. For example:

```go
fmt.Println(arr[0]) // Output: 1
```

## Modifying Array Elements

You can modify array elements by assigning a new value to the specific index:

```go
arr[0] = 10
```

This sets the first element of `arr` to 10.

## Array Operations

Go provides several built-in functions to work with arrays:

- `len(arr)`: Returns the length of the array
- `cap(arr)`: Returns the capacity of the array (same as length for arrays)

You can also use slicing to create subarrays:

```go
subArr := arr[1:3]
```

This creates a new slice `subArr` that references a portion of `arr`, containing elements at indices 1 and 2.

## Multi-Dimensional Arrays

Go supports multi-dimensional arrays. For example, a 2D array can be declared as:

```go
var matrix [3][3]int
```

This creates a 3x3 2D array of integers.

You can initialize a 2D array during declaration:

```go
matrix := [3][3]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
```

Access elements using double indexing:

```go
fmt.Println(matrix[1][1]) // Output: 5
```

## Limitations of Arrays

Arrays in Go have a fixed size that is determined when they are declared. This means that once an array is created, its size cannot be changed. If you need a data structure with a dynamic size, consider using slices instead.

Slices provide more flexibility and are built on top of arrays, allowing you to resize and manipulate the underlying array efficiently.