julia> 1 + 2 - 3 * 4  # 四則演算（除算以外）
-9

julia> 7 / 5  # `整数 / 整数` の結果は浮動小数
1.4

julia> 7 ÷ 5  # `整数 ÷ 整数` の結果は整数
1

julia> 2 ^ 10 # 冪乗は `^`
1024

julia> 123 & 234 | 345  # 論理積 / 論理和
376

julia> 123 ⊻ 234  # 排他的論理和(==`xor(123, 234)`)
145

julia> a = [1, 2, 3, 4, 5]
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> a[1]   # Julia は 1-origin
1

julia> println(a[2:3])  # 範囲指定は両端含む
[2, 3]

julia> a = [n^2 for n=1:5]
5-element Vector{Int64}:
  1
  4
  9
 16
 25

julia> A = [x+10y for y=1:3, x=1:3]
3×3 Matrix{Int64}:
 11  12  13
 21  22  23
 31  32  33

julia> [(a,b,c) for c=1:15,b=1:15,a=1:15 if a^2+a*b+b^2==c^2]
6-element Vector{Tuple{Int64, Int64, Int64}}:
 (3, 5, 7)
 (5, 3, 7)
 (6, 10, 14)
 (7, 8, 13)
 (8, 7, 13)
 (10, 6, 14)

julia> [1;2;;3;4;;;5;6;;7;8]  # 2×2×2 の3次元配列
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 5  7
 6  8

julia> [1 2;3 4;;;5 6;7 8]  # 従来記法との併用も可能（次元の順番に注意）
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 3  4

[:, :, 2] =
 5  6
 7  8

julia> [1;;;;]  # 1×1×1×1 の4次元配列
1×1×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 1

julia> x = [1., 2., 3.]; y = [3., 1., 2.];

julia> x + y  # `x .+ y` と書いても同じ（elementwise operation）
[4., 3., 5.]

julia> x .* y # これは `x * y` と書くとNG
[3., 2., 6.]

julia> using LinearAlgebra

julia> x ⋅ y  # 内積（dot積、`dot(x, y)` と書いても同じ）
11.0

julia> x × y  # 外積（cross積、`cross(x, y)` と書いても同じ）
[1., 7., -5.]

julia> A = [1 2; 3 4]   # この記法は MATLAB/Octave 由来
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A'  # `○'` は転置行列（正確には随伴行列）の記法（これも MATLAB/Octave 由来）
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  3
 2  4
 
 julia> A'ᵀ  # ← ≥ v"1.6", v"1.5" までは `transpose(A)`  # 正確には転置行列はこっち
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 1  3
 2  4

julia> A = [1 2; 3 4]; B = [3 0; 0 6];

julia> A + B  # A .+ B でも同様
2×2 Matrix{Int64}:
 4   2
 3  10

julia> A * B   # matrix multiply
2×2 Matrix{Int64}:
 3  12
 9  24

julia> A .* B   # elementwise multiply
2×2 Matrix{Int64}:
 3   0
 0  24

julia> sin(0.1)
0.09983341664682815

julia> sin.([0.1, 0.2, 0.3, 0.4])
4-element Vector{Float64}:
 0.0998334
 0.198669
 0.29552
 0.389418

julia> [0.1, 0.2, 0.3, 0.4] .^ 2
# => [0.01, 0.04, 0.09, 0.16]

julia> f(x) = x^2 + 2x - 1
f (generic function with 1 method)

julia> f(1)
2

julia> f.(1:5)
# => [2, 7, 14, 23, 34]

julia> 1//2 == 0.5
true

julia> 1//2 - 1//3
1//6

julia> 1im ^ 2 == -1
true

julia> (1.0 + 0.5im) * (2.0 - 3.0im)
3.5 - 2.0im

# 同じ要素がN個続く箇所を見つけてそのインデックスの範囲を返す
function findNrepeats(a::AbstractVector, N)
    _lastindex = lastindex(a)
    for i in eachindex(a)  # keys(a) でもOK
        r = i:i+N-1
        last(r) > _lastindex && break
        allequal(a[r]) && return r
    end
    nothing
end

julia> a = [0, 7, 7, 5, 0, 0, 0, 1, 1, 2];  # a[5:7] == [0, 0, 0]

julia> findNrepeats(a, 3)
5:7

julia> findNrepeats([3, 1, 4, 1, 5, 9, 2, 6, 5, 3], 2) === nothing
true

# 同じ要素がN個続く箇所を見つけてそのインデックスの範囲を返す ver.2
function findNrepeats_v2(a::AbstractVector, N)
    rs = [i:i+N-1 for i in eachindex(a) if i+N-1 ≤ lastindex(a)]
    index = findfirst(rs) do r
        allequal(a[r])
    end
    isnothing(index) ? nothing : rs[index]
end

julia> a = [0, 7, 7, 5, 0, 0, 0, 1, 1, 2];  # a[5:7] == [0, 0, 0]

julia> findNrepeats_v2(a, 3)
5:7

julia> findNrepeats_v2([3, 1, 4, 1, 5, 9, 2, 6, 5, 3], 2) === nothing
true

julia> using BenchmarkTools, Random

julia> N=3;

julia> Random.seed!(1234);
       @benchmark findNrepeats(a, $N) setup=(a=rand(0:9, 100))
# 出力例は画像参照

julia> Random.seed!(1234);
       @benchmark findNrepeats_v2(a, $N) setup=(a=rand(0:9, 100))
# 出力例は画像参照

# 前準備：「同じ文字のN回繰り返し」という正規表現を生成しキャッシュする仕組み
@generated function getNrepeatsRegex(::Val{N}) where {N}
    Regex("(.)" * "\\1" ^ (N-1))  # N=3 なら `r"(.)\1\1"` となる
end

# 同じ文字がN個続く箇所を見つけてそのインデックスの範囲を返す
function findNrepeats(s::AbstractString, N)
    rex = getNrepeatsRegex(Val(N))
    findfirst(rex, s)
end

julia> s = "ABC123あああ😁漢字";  # s[7:13] == "あああ"

julia> findNrepeats(s, 3)
7:13

# 同じ要素がN個続く箇所を見つけてそのインデックスの範囲を返す ver.2
function findNrepeats_v2(s::AbstractString, N)
    rex = Regex("(.)" * "\\1" ^ (N-1))  # N=3 なら `r"(.)\1\1"`
    findfirst(rex, s)
end

julia> s = "ABC123あああ😁漢字";  # s[7:13] == "あああ"

julia> findNrepeats_v2(s, 3)
7:13

julia> using BenchmarkTools, Random

julia> N=3;

julia> Random.seed!(1234);
       @benchmark findNrepeats(s, $N) setup=(
           s=randstring("123ABCあいう😁漢字", 100))
# 出力例は画像参照

julia> Random.seed!(1234);
       @benchmark findNrepeats_v2(s, $N) setup=(
           s=randstring("123ABCあいう😁漢字", 100))
# 出力例は画像参照

julia> D = Dict(["Carol", "Alice", "Ellen", "Bob", "Dave"].=>1:5);

julia> findall(isodd, D)  # 値が奇数であるようなエントリーのキーを全て列挙
3-element Vector{String}:
 "Carol"
 "Dave"
 "Ellen"

julia> [D[key] for key in findall(isodd, D)]
3-element Vector{Int64}:
 1
 5
 3

julia> # ※ ↑は結果的に `filter(isodd, collect(values(D)))` と同じ

# 第1引数で条件判定して、第2引数のコレクションで最初に合致する要素を返す
# （なければ `nothing`）
function meetfirst_v1(pred::Function, itr)
    # NG: `return first(Iterators.dropwhile(!pred, itr))`
    itr2 = Iterators.dropwhile(!pred, itr)
    try
        first(itr2)
    catch e
        if isa(e, BoundsError) || isa(e, ArgumentError)
            return nothing
        end
        rethrow(e)
    end
end

julia> a = [314, 159, 265, 358, 979, 323, 846, 264];

julia> meetfirst_v1(n -> n % 11 == 0, a)
979

julia> meetfirst_v1(n -> n % 7 == 0, a) === nothing
true

julia> # コラッツ数列を列挙するイテレータ（`Channel`）を返す関数
       function collatz(n::Int)
           Channel{Int}() do chnl
               put!(chnl, n)
               while n > 1
                   n = iseven(n) ? n ÷ 2 : 3n + 1
                   put!(chnl, n)
               end
           end
       end
collatz (generic function with 1 method)

julia> meetfirst_v1(≥(200), collatz(27))
214

julia> meetfirst_v1(≥(50), collatz(3)) === nothing
true

# 第1引数で条件判定して、第2引数のコレクションで最初に合致する要素を返す
# （なければ `nothing`） ver.2
function meetfirst(pred::Function, itr)
    itr2 = Iterators.dropwhile(!pred, itr)
    next = iterate(itr2)
    isnothing(next) ? nothing : first(next)  # `first(next)` はタプルの第1要素を取得している
end

julia> a = [314, 159, 265, 358, 979, 323, 846, 264];

julia> meetfirst(n -> n % 11 == 0, a)
979

julia> meetfirst(n -> n % 7 == 0, a) === nothing
true

julia> # コラッツ数列を列挙するイテレータ（`Channel`）を返す関数
       function collatz end;  # 長いので略

julia> meetfirst(≥(200), collatz(27))
214

julia> meetfirst(≥(50), collatz(3)) === nothing
true

julia> using BenchmarkTools, Random

julia> Random.seed!(1234);
       @benchmark meetfirst_v1(≥(200), c) setup=(c=collatz(rand(3:100)))
# 出力例は画像参照

julia> Random.seed!(1234);
       @benchmark meetfirst(≥(200), c) setup=(c=collatz(rand(3:100)))
# 出力例は画像参照

julia> jgm0 = "寿限無寿限無五劫の擦り切れ海砂利水魚の水行末雲来末風来末食う寝る処に住む処やぶらこうじのぶらこうじパイポ・パイポ・パイポのシューリンガン・シューリンガンのグーリンダイ・グーリンダイのポンポコピーのポンポコナの長久命の長助";

julia> jgm1 = "寿限無寿限無五劫の擦り切れ\
海砂利水魚の水行末雲来末風来末\
食う寝る処に住む処やぶらこうじのぶらこうじ\
パイポ・パイポ・パイポのシューリンガン・\
シューリンガンのグーリンダイ・グーリンダイのポンポコピーのポンポコナの\
長久命の長助";

julia> jgm2 = """
    寿限無寿限無五劫の擦り切れ海砂利水魚の水行末雲来末風来末\
    食う寝る処に住む処やぶらこうじのぶらこうじ\
    パイポ・パイポ・パイポのシューリンガン・シューリンガンのグーリンダイ・\
    グーリンダイのポンポコピーのポンポコナの\
    長久命の長助""";
# ↑ `"""～"""` ならインデントも無視されるのでさらに見やすく！

julia> jgm0 == jgm1 == jgm2  # もちろん文字列として同一視できる
true

julia> jgm0 === jgm1 === jgm2  # リテラルとしても同一になる（今回の場合）！
true

julia> jgm0 = "寿限無寿限無五劫の擦り切れ海砂利水魚の水行末雲来末風来末食う寝る処に住む処やぶらこうじのぶらこうじパイポ・パイポ・パイポのシューリンガン・シューリンガンのグーリンダイ・グーリンダイのポンポコピーのポンポコナの長久命の長助";

julia> jgm_oldstyle =
           "寿限無寿限無五劫の擦り切れ" * 
           "海砂利水魚の水行末雲来末風来末" *
           "食う寝る処に住む処やぶらこうじのぶらこうじ" *
           "パイポ・パイポ・パイポのシューリンガン・" *
           "シューリンガンのグーリンダイ・グーリンダイのポンポコピーのポンポコナの" *
           "長久命の長助";

julia jgm0 == jgm_oldstyle
true

julia> # 標準の Dict： 順不同
       dic = Dict(["Carol", "Alice", "Ellen", "Bob", "Dave"].=>1:5)
Dict{String, Int64} with 5 entries:
  "Carol" => 1
  "Alice" => 2
  "Dave"  => 5
  "Ellen" => 3
  "Bob"   => 4

(@v1.x) pkg> add DataStructures
# 出力例略

julia> using DataStructures

julia> # OrderedDict: 追加順
       odic = OrderedDict(["Carol", "Alice", "Ellen", "Bob", "Dave"].=>1:5)
OrderedDict{String, Int64} with 5 entries:
  "Carol" => 1
  "Alice" => 2
  "Ellen" => 3
  "Bob"   => 4
  "Dave"  => 5

julia> # 標準の Set: 順不同
       set = Set(["Carol", "Alice", "Ellen", "Bob", "Dave"])
Set{String} with 5 elements:
  "Carol"
  "Alice"
  "Dave"
  "Ellen"
  "Bob"

(@v1.x) pkg> add DataStructures
# 出力例略

julia> using DataStructures

julia> # SortedSet: 値の昇順
       sset = SortedSet(["Carol", "Alice", "Ellen", "Bob", "Dave"])
SortedSet{String, Base.Order.ForwardOrdering} with 5 elements:
  "Alice"
  "Bob"
  "Carol"
  "Dave"
  "Ellen"

julia> dkeys = ["Carol", "Alice", "Ellen", "Bob", "Dave"];

julia> dic = Dict(dkeys.=>1:5)
Dict{String, Int64} with 5 entries:
  "Carol" => 1
  "Alice" => 2
  "Dave"  => 5
  "Ellen" => 3
  "Bob"   => 4

julia> # 追加順に列挙
       for key in dkeys
           println("$(key) => $(dic[key])")
       end
Carol => 1
Alice => 2
Ellen => 3
Bob => 4
Dave => 5

julia> # キーの昇順に列挙
       for key in sort(dkeys)
           println("$(key) => $(dic[key])")
       end
Alice => 2
Bob => 4
Carol => 1
Dave => 5
Ellen => 3

julia> fn = x -> x * x
#45 (generic function with 1 method)

julia> # 関数 `fn`（正確には変数 `fn` に格納されている無名関数）の多重定義
       (::typeof(fn))(x, y) = x * y

julia> methods(fn)
# 2 methods for anonymous function "#45":
[1] (::var"#45#46")(x) in Main at REPL[121]:1
[2] (::var"#45#46")(x, y) in Main at REPL[122]:2

julia> @show fn(5) fn(5, 8)
fn(5) = 25
fn(5, 8) = 40
40

help?> nextind
search: nextind IndexCartesian MissingException current_exceptions InterruptException InvalidStateException

  nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int

# ：《中略》

•  Case n > 1
       Behaves like applying n times nextind for n==1. The only difference is that if n is so large that applying
       nextind would reach ncodeunits(str)+1 then each remaining iteration increases the returned value by 1.
       This means that in this case nextind can return a value greater than ncodeunits(str)+1.

# ：《以下略》

julia> s = "123ABCあいう😁漢字";

julia> nextind(s, 0, 10)  # `0` より後で `10` 番目の文字のインデックス
16

julia> s[nextind(s, 0, 10)]  # `s` の10文字目
'😁': Unicode U+1F601 (category So: Symbol, other)

julia> # `thisind()`: 指定したあたりに存在する文字の正しいインデックス番号を返す

julia> s = "123ABCあいう😁漢字";

julia> thisind(s, 9)
7

julia> s[thisind(s, 9)]
'あ': Unicode U+3042 (category Lo: Letter, other)

julia> # `prevind()`：「後ろから何文字目」という指定が可能

julia> s[prevind(s, end+1, 3)]  # 後ろから3文字目の文字
'😁': Unicode U+1F601 (category So: Symbol, other)

julia> s = "123ABCあいう😁漢字";

julia> # 文字列の全てのインデックスを列挙するなら↓

julia> eachindex(s)
Base.EachStringIndex{String}("123ABCあいう😁漢字")

julia> collect(eachindex(s))
12-element Vector{Int64}:
  1
  2
  3
  4
  5
  6
  7
 10
 13
 16
 20
 23

julia> s = "123ABCあいう😁漢字";

julia> split(s, "")[10]
"😁"