Code Examples

Real-world examples to learn from and use in your projects

Algorithms

Quicksort Intermediate 
fn quicksort(arr, low, high)
    if low < high then
        let pivot = partition(arr, low, high)
        quicksort(arr, low, pivot - 1)
        quicksort(arr, pivot + 1, high)
    end
end

fn partition(arr, low, high)
    let pivot = arr[high]
    let i = low - 1
    for j in low..high do
        if arr[j] <= pivot then
            i = i + 1
            let temp = arr[i]
            arr[i] = arr[j]
            arr[j] = temp
        end
    end
    let temp = arr[i + 1]
    arr[i + 1] = arr[high]
    arr[high] = temp
    return i + 1
end
Classic divide-and-conquer sorting algorithm
Binary Search Beginner 
fn binary_search(arr, target)
    let left = 0
    let right = len(arr) - 1
    
    while left <= right do
        let mid = floor((left + right) / 2)
        
        if arr[mid] == target then
            return mid
        elif arr[mid] < target then
            left = mid + 1
        else
            right = mid - 1
        end
    end
    
    return -1  // Not found
end

let nums = [1, 3, 5, 7, 9, 11]
print(binary_search(nums, 7))  // 3
O(log n) search in sorted arrays
Fibonacci with Memoization Intermediate 
// Dynamic programming approach
fn fibonacci(n)
    let memo = {"0": 0, "1": 1}
    return fib_helper(n, memo)
end

fn fib_helper(n, memo)
    let key = str(n)
    if dict_has(memo, key) then
        return memo[key]
    end
    
    let result = fib_helper(n-1, memo) + fib_helper(n-2, memo)
    memo[key] = result
    return result
end

print(fibonacci(50))  // 12586269025
O(n) time with memoization vs O(2^n) naive
Merge Sort Intermediate 
fn merge_sort(arr)
    if len(arr) <= 1 then
        return arr
    end
    
    let mid = floor(len(arr) / 2)
    let left = merge_sort(slice(arr, 0, mid))
    let right = merge_sort(slice(arr, mid))
    
    return merge(left, right)
end

fn merge(left, right)
    let result = []
    let i = 0
    let j = 0
    
    while i < len(left) and j < len(right) do
        if left[i] <= right[j] then
            push(result, left[i])
            i = i + 1
        else
            push(result, right[j])
            j = j + 1
        end
    end
    
    return concat(result, concat(slice(left, i), slice(right, j)))
end
Stable O(n log n) sorting algorithm

Web & APIs

REST API Client Beginner 
// Fetch data from a REST API
fn get_user(user_id)
    let url = "https://api.example.com/users/" + str(user_id)
    let response = http_get(url)
    return json_parse(response)
end

fn create_user(name, email)
    let url = "https://api.example.com/users"
    let data = json_stringify({
        "name": name,
        "email": email
    })
    let response = http_post(url, data)
    return json_parse(response)
end

// Usage
let user = get_user(123)
print("Name: " + user["name"])
HTTP GET and POST with JSON parsing
Weather API Beginner 
fn get_weather(city)
    let api_key = env("WEATHER_API_KEY")
    let url = "https://api.weather.com/v1/" + city
    url = url + "?key=" + api_key
    
    let response = http_get(url)
    let data = json_parse(response)
    
    print("City: " + data["name"])
    print("Temp: " + str(data["temp"]) + "°C")
    print("Conditions: " + data["conditions"])
    
    return data
end

get_weather("Tokyo")
Real-world API integration with environment variables
GitHub API Intermediate 
fn get_repos(username)
    let url = "https://api.github.com/users/"
    url = url + username + "/repos"
    
    let response = http_get(url)
    let repos = json_parse(response)
    
    print("Repositories for " + username + ":")
    print("=========================")
    
    for repo in repos do
        let stars = repo["stargazers_count"]
        let name = repo["name"]
        print("⭐ " + str(stars) + " - " + name)
    end
end

get_repos("NagusameCS")
Fetch and display GitHub repositories

File I/O

CSV Parser Intermediate 
fn parse_csv(filename)
    let content = read_file(filename)
    let lines = split(content, "\n")
    let result = []
    
    // Get headers from first line
    let headers = split(lines[0], ",")
    
    // Parse data rows
    for i in 1..len(lines) do
        let values = split(lines[i], ",")
        let row = {}
        
        for j in 0..len(headers) do
            row[trim(headers[j])] = trim(values[j])
        end
        
        push(result, row)
    end
    
    return result
end

let data = parse_csv("users.csv")
for row in data do
    print(row["name"] + ": " + row["email"])
end
Parse CSV files into dictionaries
Log File Analyzer Intermediate 
fn analyze_logs(filename)
    let content = read_file(filename)
    let lines = split(content, "\n")
    
    let errors = 0
    let warnings = 0
    let info = 0
    
    for line in lines do
        if contains(line, "ERROR") then
            errors = errors + 1
        elif contains(line, "WARN") then
            warnings = warnings + 1
        elif contains(line, "INFO") then
            info = info + 1
        end
    end
    
    print("=== Log Analysis ===")
    print("Errors:   " + str(errors))
    print("Warnings: " + str(warnings))
    print("Info:     " + str(info))
end

analyze_logs("server.log")
Count log levels in a log file
JSON Config Handler Beginner 
fn load_config(path)
    if not file_exists(path) then
        print("Creating default config...")
        save_config(path, {
            "theme": "dark",
            "language": "en",
            "debug": false
        })
    end
    
    let content = read_file(path)
    return json_parse(content)
end

fn save_config(path, config)
    let json = json_stringify(config, 2)
    write_file(path, json)
end

let config = load_config("config.json")
print("Theme: " + config["theme"])
Load and save JSON configuration files

Math & Science

Prime Number Sieve Intermediate 
fn sieve_of_eratosthenes(n)
    let is_prime = []
    for i in 0..(n+1) do
        push(is_prime, true)
    end
    is_prime[0] = false
    is_prime[1] = false
    
    let p = 2
    while p * p <= n do
        if is_prime[p] then
            let multiple = p * p
            while multiple <= n do
                is_prime[multiple] = false
                multiple = multiple + p
            end
        end
        p = p + 1
    end
    
    let primes = []
    for i in 2..(n+1) do
        if is_prime[i] then
            push(primes, i)
        end
    end
    return primes
end

print(sieve_of_eratosthenes(50))
Efficient prime number generation
Matrix Operations Advanced 
fn matrix_multiply(a, b)
    let rows_a = len(a)
    let cols_a = len(a[0])
    let cols_b = len(b[0])
    
    // Initialize result matrix
    let result = []
    for i in 0..rows_a do
        let row = []
        for j in 0..cols_b do
            push(row, 0)
        end
        push(result, row)
    end
    
    // Compute product
    for i in 0..rows_a do
        for j in 0..cols_b do
            for k in 0..cols_a do
                result[i][j] = result[i][j] + a[i][k] * b[k][j]
            end
        end
    end
    
    return result
end
Matrix multiplication implementation
Statistical Functions Beginner 
fn mean(arr)
    return vec_sum(arr) / len(arr)
end

fn variance(arr)
    let avg = mean(arr)
    let sum_sq = 0
    for x in arr do
        sum_sq = sum_sq + (x - avg) * (x - avg)
    end
    return sum_sq / len(arr)
end

fn std_dev(arr)
    return sqrt(variance(arr))
end

let data = [2, 4, 4, 4, 5, 5, 7, 9]
print("Mean: " + str(mean(data)))
print("Std Dev: " + str(std_dev(data)))
Mean, variance, and standard deviation

Data Structures

Stack Beginner 
// Stack implementation using closures
fn create_stack()
    let items = []
    
    return {
        "push": fn(item) push(items, item) end,
        "pop": fn() return pop(items) end,
        "peek": fn() return items[len(items)-1] end,
        "size": fn() return len(items) end,
        "empty": fn() return len(items) == 0 end
    }
end

let stack = create_stack()
stack["push"](1)
stack["push"](2)
stack["push"](3)
print(stack["pop"]())  // 3
print(stack["peek"]()) // 2
LIFO data structure implementation
Queue Beginner 
fn create_queue()
    let items = []
    
    return {
        "enqueue": fn(item) push(items, item) end,
        "dequeue": fn() return shift(items) end,
        "front": fn() return items[0] end,
        "size": fn() return len(items) end,
        "empty": fn() return len(items) == 0 end
    }
end

let queue = create_queue()
queue["enqueue"]("first")
queue["enqueue"]("second")
queue["enqueue"]("third")
print(queue["dequeue"]())  // first
print(queue["front"]())   // second
FIFO data structure implementation
Hash Map with Chaining Advanced 
fn create_hashmap(size)
    let buckets = []
    for i in 0..size do
        push(buckets, [])
    end
    
    fn hash_key(key)
        return hash(key) % size
    end
    
    return {
        "set": fn(key, value)
            let idx = hash_key(key)
            let bucket = buckets[idx]
            for pair in bucket do
                if pair[0] == key then
                    pair[1] = value
                    return
                end
            end
            push(bucket, [key, value])
        end,
        "get": fn(key)
            let idx = hash_key(key)
            for pair in buckets[idx] do
                if pair[0] == key then
                    return pair[1]
                end
            end
            return nil
        end
    }
end
Hash table with collision resolution