Top 30 Julia Coding Challenges for Junior to Senior Developers

The traditional first program to verify a working setup.

println("Hello, World!")

A basic test of loops and array manipulation.

function sum_array(arr)
    total = 0
    for x in arr
        total += x
    end
    total
end

A simple test of string manipulation.

reverse("Hello, World!")

A fundamental algorithm using a simple loop.

function find_largest(arr)
    largest = arr[1]
    for x in arr
        if x > largest
            largest = x
        end
    end
    largest
end

Tests string manipulation and comparison logic.

function is_palindrome(s)
    s == reverse(s)
end

The classic test of basic conditional logic and loops.

function fizzbuzz(n)
    for i in 1:n
        if i % 15 == 0
            println("FizzBuzz")
        elseif i % 3 == 0
            println("Fizz")
        elseif i % 5 == 0
            println("Buzz")
        else
            println(i)
        end
    end
end

Introduces custom types and data organization.

struct Person
    name::String
    age::Int
end

A simple function to demonstrate tuple creation.

function get_person()
    ("John Doe", 30)
end

A basic loop to demonstrate syntax.

for i in 1:10
    println(i)
end

Tests basic conditional logic.

function check_number(n)
    if n > 0
        println("Positive")
    elseif n < 0
        println("Negative")
    else
        println("Zero")
    end
end

Use a `Dict` to count the frequency of words in a text.

function word_count(s)
    counts = Dict{String, Int}()
    for word in split(s)
        counts[word] = get(counts, word, 0) + 1
    end
    counts
end

A simple abstract type for a `Shape`.

abstract type Shape end

struct Circle <: Shape
    radius::Float64
end

struct Square <: Shape
    side::Float64
end

Convert Julia structs to and from JSON using `JSON.jl`.

using JSON

struct Person
    name::String
    age::Int
end

person = Person("John Doe", 30)
json_string = JSON.json(person)
person2 = JSON.parse(json_string)

A common interview question that can be solved with a `Dict`.

function first_non_repeating(s)
    counts = Dict{Char, Int}()
    for c in s
        counts[c] = get(counts, c, 0) + 1
    end
    for c in s
        if counts[c] == 1
            return c
        end
    end
end

A simple generic function that takes an array of any type that supports the `+` operator.

function sum_array(arr::Vector{T}) where T <: Number
    total = zero(T)
    for x in arr
        total += x
    end
    total
end

A simple example of error handling with `try`/`catch`.

function do_something(fail)
    if fail
        error("Something went wrong")
    end
end

try
    do_something(true)
catch e
    println(e)
end

A simple example of an anonymous function.

map(x -> x^2, [1, 2, 3])

A simple command-line argument parser.

for arg in ARGS
    println(arg)
end

A simple example of reading and writing to a file.

open("foo.txt", "w") do f
    write(f, "Hello, world!")
end

open("foo.txt", "r") do f
    println(read(f, String))
end

A simple implementation of a linked list.

mutable struct Node
    data::Int
    next::Union{Node, Nothing}
end

mutable struct LinkedList
    head::Union{Node, Nothing}
end

A thread-safe counter using `Threads.@threads`.

using Base.Threads

function thread_safe_counter(n)
    counter = Atomic{Int}(0)
    @threads for i in 1:n
        atomic_add!(counter, 1)
    end
    counter[]
end

A simple web server with `HTTP.jl`.

using HTTP

HTTP.serve() do request::HTTP.Request
    HTTP.Response("Hello, world!")
end

A simple memory allocator.

# This is a complex task that would require a lot of code.
# A full implementation would be too long for this format.

A simple macro.

macro five()
    5
end

@five()

A simple async runtime.

# This is a complex task that would require a lot of code.
# A full implementation would be too long for this format.

A simple example of using `ccall` to interact with C code.

ccall(:abs, Int, (Int,), -1)

A simple concurrent queue.

using Base.Threads

struct ConcurrentQueue
    lock::ReentrantLock
    cond::Condition
    queue::Vector{Int}
end

function push!(q::ConcurrentQueue, x)
    lock(q.lock)
    try
        push!(q.queue, x)
        notify(q.cond)
    finally
        unlock(q.lock)
    end
end

function pop!(q::ConcurrentQueue)
    lock(q.lock)
    try
        while isempty(q.queue)
            wait(q.cond)
        end
        popfirst!(q.queue)
    finally
        unlock(q.lock)
    end
end

A simple key-value store.

struct KvStore
    data::Dict{String, String}
end

function set!(kv::KvStore, key, value)
    kv.data[key] = value
end

function get(kv::KvStore, key)
    get(kv.data, key, nothing)
end

A simple state machine.

@enum State start running stop

mutable struct StateMachine
    state::State
end

function transition!(sm::StateMachine, new_state)
    sm.state = new_state
end

A simple build script for a project.

# In build.jl
using Pkg.Artifacts

artifact_toml = joinpath(@__DIR__, "Artifacts.toml")
# ...