数组 #

arr1 = [1, 2, 3, 4, 5]
arr2 = ["a", "b", "c"]
arr3 = [1, 2.0, 3]
arr4 = []

typeof([1, 2, 3])
typeof([1.0, 2.0, 3.0])
typeof([1, 2.0, 3])
typeof([])

Int[1, 2, 3]
Float64[1, 2, 3]
String["a", "b", "c"]
Any[1, "a", 2.0]

zeros(5)
zeros(Int, 5)
ones(3)
ones(Float64, 3)
fill(0, 5)
fill("hello", 3)

Vector{Int}(undef, 5)
Array{Int, 1}(undef, 5)
Matrix{Float64}(undef, 3, 3)

[x^2 for x in 1:5]
[x * y for x in 1:3, y in 1:3]
[x for x in 1:10 if x % 2 == 0]

arr = [10, 20, 30, 40, 50]
arr[1]
arr[5]
arr[end]
arr[begin]

arr = [10, 20, 30, 40, 50]
arr[end]
arr[end-1]
arr[end-2]

arr = [1, 2, 3]
arr[0]
arr[4]

arr = [1, 2, 3]
getindex(arr, 1)
get(arr, 4, nothing)

arr = [1, 2, 3, 4, 5]
arr[1:3]
arr[2:end]
arr[begin:3]
arr[:]

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
arr[1:2:end]
arr[2:2:end]
arr[end:-1:begin]

arr = [1, 2, 3, 4, 5]
v = view(arr, 2:4)
v[1] = 20
arr

@view arr[2:4]
@views arr[2:4] .+ 1

arr = [1, 2, 3]
push!(arr, 4)
push!(arr, 5, 6)
pushfirst!(arr, 0)
append!(arr, [7, 8, 9])

arr = [1, 2, 3, 4, 5]
pop!(arr)
popfirst!(arr)
deleteat!(arr, 2)
splice!(arr, 2)
empty!(arr)

arr = [1, 2, 3]
insert!(arr, 2, 10)
splice!(arr, 2, [10, 20, 30])

arr = [1, 2, 3, 4, 5]
arr[1] = 10
arr[2:3] = [20, 30]

[1, 2, 3] ∪ [3, 4, 5]
vcat([1, 2], [3, 4])
hcat([1, 2], [3, 4])
[[1, 2], [3, 4]]

arr = [1, 2, 3, 4, 5]
length(arr)
size(arr)
ndims(arr)
eltype(arr)
isempty(arr)

arr = [1, 2, 3, 2, 4, 2]
findfirst(x -> x == 2, arr)
findlast(x -> x == 2, arr)
findall(x -> x == 2, arr)
findmax(arr)
findmin(arr)

arr = [1, 2, 3, 4, 5]
in(3, arr)
3 ∈ arr
3 ∉ arr
any(x -> x > 3, arr)
all(x -> x > 0, arr)

arr = [3, 1, 4, 1, 5, 9, 2, 6]
sort(arr)
sort!(arr)
sort(arr, rev=true)

arr = [3, 1, 4, 1, 5, 9, 2, 6]
sortperm(arr)
arr[sortperm(arr)]

arr = ["apple", "banana", "cherry"]
sort(arr, by=length)
sort(arr, by=uppercase)
sort(arr, lt=(a, b) -> length(a) < length(b))

arr = [3, 1, 4, 1, 5, 9, 2, 6]
partialsort(arr, 1:3)
partialsortperm(arr, 1:3)

arr = [1, 2, 3, 4, 5]
sum(arr)
prod(arr)
minimum(arr)
maximum(arr)
extrema(arr)

using Statistics

arr = [1, 2, 3, 4, 5]
mean(arr)
median(arr)
std(arr)
var(arr)

arr = [1, 2, 3, 4, 5]
cumsum(arr)
cumprod(arr)
accumulate(+, arr)
accumulate(*, arr)

arr = [1, 2, 3, 4, 5]
reduce(+, arr)
foldl(+, arr)
foldr(+, arr)
mapreduce(x -> x^2, +, arr)

arr = [1, 2, 3, 4, 5]
map(x -> x^2, arr)
[x^2 for x in arr]

arr = [1, 2, 3, 4, 5]
filter(x -> x % 2 == 0, arr)
filter!(x -> x % 2 == 0, arr)

arr = [1, 2, 3, 2, 4, 2]
replace(arr, 2 => 10)
replace!(arr, 2 => 10)

arr = [1, 2, 3, 2, 4, 2, 3]
unique(arr)
unique!(arr)
allunique(arr)

arr = [1, 2, 3, 4, 5]
reverse(arr)
reverse!(arr)

mat = [1 2 3; 4 5 6; 7 8 9]
zeros(3, 3)
ones(2, 4)
Matrix{Float64}(undef, 3, 3)
rand(3, 3)

mat = [1 2 3; 4 5 6; 7 8 9]
mat[1, 1]
mat[2, 3]
mat[end, end]
mat[1, :]
mat[:, 1]
mat[1:2, 2:3]

mat = [1 2 3; 4 5 6; 7 8 9]
mat[1]
mat[5]
CartesianIndices(mat)
LinearIndices(mat)

A = [1 2; 3 4]
B = [5 6; 7 8]

A * B
A + B
A - B
A'
transpose(A)
inv(A)
det(A)

arr3d = rand(2, 3, 4)
size(arr3d)
ndims(arr3d)
arr3d[1, 2, 3]
arr3d[:, :, 1]

arr = [1, 2, 3, 4, 5]
arr .^ 2
arr .+ 1
sin.(arr)

arr = [1, 2, 3, 4, 5]
broadcast(x -> x^2, arr)
broadcast(+, arr, 1)
broadcast(+, [1, 2], [3, 4])

a = [1, 2, 3]
b = [10, 20, 30]
a .+ b
a .* b

arr = [1, 2, 3, 4, 5]
arr .*= 2
arr .+= 1

function array_stats(arr)
    (
        length = length(arr),
        sum = sum(arr),
        mean = sum(arr) / length(arr),
        min = minimum(arr),
        max = maximum(arr),
        unique_count = length(unique(arr))
    )
end

array_stats([1, 2, 3, 4, 5, 3, 2, 1])

function remove_duplicates(arr)
    seen = Set{eltype(arr)}()
    result = similar(arr, 0)
    for x in arr
        if !(x in seen)
            push!(result, x)
            push!(seen, x)
        end
    end
    return result
end

remove_duplicates([1, 2, 3, 2, 4, 3, 5])

function matrix_multiply(A, B)
    rows_A, cols_A = size(A)
    rows_B, cols_B = size(B)
    
    cols_A == rows_B || error("Dimension mismatch")
    
    C = zeros(rows_A, cols_B)
    for i in 1:rows_A
        for j in 1:cols_B
            for k in 1:cols_A
                C[i, j] += A[i, k] * B[k, j]
            end
        end
    end
    return C
end

A = [1 2; 3 4]
B = [5 6; 7 8]
matrix_multiply(A, B) == A * B

function sliding_window(arr, window_size)
    [arr[i:i+window_size-1] for i in 1:length(arr)-window_size+1]
end

sliding_window([1, 2, 3, 4, 5], 3)