# Print the first 10 prime numbers
say 10.primes

# Exact decimal math (no floating-point surprises!)
say (0.1 + 0.2 == 0.3)    # true

# Factorial of 100 — a 158-digit number!
say 100!

# Sum all numbers from 1 to 100
say (1..100).sum

#!/usr/bin/sidef

say "Hello, World!"

# This is a single-line comment.
say "Hello!"    # Comments can go at the end of a line too.

/*
   This is a multi-line comment.
   It can span as many lines as you need.
   Useful for longer explanations.
*/
say "After the comment block."

var num  = 42
var str  = "42"
var bool = true

var x = 42
say x         # prints: 42

for k in (1..10) {
    static x = (41 + k)   # assigned only on the first iteration (k=1)
    say x                 # always prints: 42
}

global x = 42
say x         # prints: 42

global x = 42
do {
    local x = 100
    say x         # prints: 100  (local value)
}
say x             # prints: 42   (global value restored)

var x = 'o'

do {
    say x          # o  (outer x)
    var x = 'm'
    say x          # m  (middle x)
    do {
        say x      # m  (still middle x)
        var x = 'b'
        say x      # b  (inner x)
    }
    say x          # m  (inner x is gone)
}

say x              # o  (back to outer x)

var (x, y, z) = (3.14, false, "foo")

var (x, y=755, z=777) = (666, 655)

say x    # 666
say y    # 655  (overridden by the assignment)
say z    # 777  (default kept, nothing assigned)

var (
    a = 42,
   *b = (1,2,3,4),          # slurpy array (see below)
   :c = (x => 1, y => 2),   # slurpy hash  (see below)
)

say a   #=> 42
say b   #=> [1,2,3,4]
say c   #=> Hash(x => 1, y => 2)

var (
    a = 42,
    b = (10 + a)    # refers to a above
)

say a   #=> 42
say b   #=> 52

var *arr  = (1,2,3)              # Array
var :hash = (a => 1, b => 2)     # Hash

say arr    # [1,2,3]
say hash   # Hash(a => 1, b => 2)

var x = 'sidef'
say x.uc    # SIDEF
say x       # sidef  (unchanged)

var x = 'sidef'
x.uc!
say x       # SIDEF

var x = 5
x += 10
say x       # 15

var x = nil
x := 42     # x is nil, so it gets assigned 42
x := 99     # x is already defined, so this is ignored
say x       # 42

var hash = Hash()
hash{:key} := [] << (1,2)
hash{:key} := [] << 3
say hash{:key}    #=> [1,2,3]

var hash = Hash()
hash{:key} := 0 -> max!(10)
hash{:key} := 0 -> max!(42)
say hash{:key}    #=> 42

var x = nil
x \\ say "x is not defined"    # prints: x is not defined

var foo = 42
del foo
say foo    # parse-time error: attempt to use deleted identifier

[25, 36, 49].map { .sqrt }
            .each { .log.say }

say [[41,'a'], [42,'b'], [43,'c']].map { .[0] }
#=> [41, 42, 43]

say [Hash(a=>41), Hash(a=>42), Hash(a=>43)].map { .{:a} }
#=> [41, 42, 43]

ARGV.each { |arg| say arg }
say ENV{:HOME}

STDERR.say("Some error!")
STDOUT.say("Some output...")
STDIN.readline()    # reads one line from standard input

ARGF.each { |line| say line }

DATA.each { |line| say "=>> #{line}" }

__DATA__
here are
some data
lines

const pi = 3.14
say pi      # 3.14

func f(a) {
    const x = a
    return (x + 2)
}

say f(40)   #=> 42
say f(50)   #=> 52

define PHI =  (1.25.sqrt + 0.5)
define IHP = -(1.25.sqrt - 0.5)

say (PHI**12 - IHP**12 / (PHI-IHP))   #=> 144

enum |Black, White|
say Black   # 0
say White   # 1

enum |α="a", β|
say α   # 'a'
say β   # 'b'

const (        # or: define ( ... ) or static ( ... )
    a = 42,
   *b = (1,2,3,4),
   :c = (x => 1, y => 2),
)

var name = "sidef"
var ref      = \name    # take a reference
var original = *ref     # dereference

func assign2ref(ref, value) {
    *ref = value
}

var x = 10
assign2ref(\x, 20)
say x    # 20

var a = 255          # decimal
var b = 0xff         # hexadecimal (same value: 255)
var c = 0b11111111   # binary      (same value: 255)
var d = 0377         # octal       (same value: 255)

# Underscores make large numbers readable
var million = 1_000_000
var big     = 1_234_567_890

say (0.1 + 0.2)           # 0.3  (exact!)
say (0.1 + 0.2 == 0.3)    # true (unlike most languages)
say (1/3 + 1/3 + 1/3)     # 1    (exact fraction arithmetic)

say (2 ** 100)        # 1267650600228229401496703205376
say 50.factorial      # a 65-digit number
say 100!              # a 158-digit number (! is factorial postfix)

say 42.is_even        # true
say 43.is_odd         # true
say (-5).abs          # 5
say 3.14.floor        # 3
say 3.14.ceil         # 4
say 3.75.round        # 4
say 16.sqrt           # 4
say 2.log             # natural logarithm of 2
say 100.log10         # 2  (log base 10)

say 7.is_prime        # true
say 12.is_prime       # false

say Inf     # infinity
say -Inf    # negative infinity
say NaN     # not a number (result of invalid operations)

var name = "Alice"
say "Hello, #{name}!"           # Hello, Alice!
say "Two plus two is #{(2+2)}"  # Two plus two is 4
say "Tab:\there"                # Tab:    here
say "Newline:\nSecond line"     # prints on two lines

var items = 5
say "You have #{items} item#{(items == 1 ? '' : 's')}."
# You have 5 items.

say 'Hello, #{name}!'    # Hello, #{name}!  (printed literally)
say 'No \n escape here'  # No \n escape here

var first = "Hello"
var second = "World"
say (first + ", " + second + "!")    # Hello, World!

say ("ha" * 3)       # hahaha
say ("-" * 20)       # --------------------

var message = <<'END'
This is a
multi-line string.
No interpolation here.
END

var greeting = <<-"END"
    Hello, #{name}!
    Welcome to Sidef.
    END

var is_raining = true
var is_sunny   = false

say is_raining    # true
say is_sunny      # false

if (0) {
    say "This won't print."
}

if ("hello") {
    say "This will print!"    # prints
}

var x = nil
say x.is_nil    # true

# Conditional assignment: only assign if currently nil
var result = nil
result := compute_value()    # only called if result is nil

say (10 + 3)    # 13  addition
say (10 - 3)    # 7   subtraction
say (10 * 3)    # 30  multiplication
say (10 / 3)    # 10/3 (exact fraction)
say (10 % 3)    # 1   modulo (remainder)
say (10 ** 3)   # 1000 exponentiation (power)

say (5 == 5)    # true  (equal)
say (5 != 3)    # true  (not equal)
say (5 >  3)    # true  (greater than)
say (5 <  10)   # true  (less than)
say (5 >= 5)    # true  (greater than or equal)
say (5 <= 10)   # true  (less than or equal)

say (true && false)    # false  (and — both must be true)
say (true || false)    # true   (or — at least one must be true)
say (!true)            # false  (not — flips true/false)

var n = 5
n++     # n is now 6
n--     # n is now 5
++n     # n is now 6 (prefix: increments before returning value)

say ("apple" == "apple")    # true
say ("apple" != "banana")   # true
say ("apple" lt "banana")   # true  (alphabetically less than)
say ("banana" gt "apple")   # true  (alphabetically greater than)

#
# Example 1: spaces between ALL operators → left to right
#
say (1 + 2 * 3 + 4)    # means: ((1+2) * 3) + 4 = 13
#          ↑
#     evaluated as: ((1 + 2) * 3) + 4

#
# Example 2: no spaces → binds tightly
#
say (1 + 2*3 + 4)      # means: 1 + (2*3) + 4 = 11
#         ↑
#     2*3 is one tight unit

#
# Example 3: mixing both
#
say (1+2 * 3+4)        # means: (1+2) * (3+4) = 21
#    ↑↑↑   ↑↑↑
#   tight  tight → each becomes a unit, then * is evaluated

# These are all clear and unambiguous:
var area    = (length * width)
var average = ((a + b + c) / 3)
var hyp     = ((a**2 + b**2).sqrt)
var tax     = (price * (1 + tax_rate))

say (1 + 2 \* 3)     # means 1 + (2 * 3) = 7
say (1 + 2 .* 3)     # same thing

say "Hello, World!"       # prints with a newline at the end
print "No newline here"   # prints without a newline
say ""                    # prints a blank line

say "Name: ", "Alice"        # Name: Alice
say 1, 2, 3                  # 123
say [1, 2, 3]                # [1, 2, 3]

> "Hello!"    # same as: say "Hello!"

var name  = "Alice"
var score = 98.5

say "Player: #{name}, Score: #{score}"
# Player: Alice, Score: 98.5

# Formatting numbers
say "Pi ≈ #{Num.pi.round(4)}"    # Pi ≈ 3.1416
say "Big: #{(10**20).commify}"   # Big: 100,000,000,000,000,000,000

print "What is your name? "
var name = read(String)

say "Hello, #{name}!"

print "Enter a number: "
var n = read(Number)

say "You entered: #{n}"
say "Its square is: #{(n ** 2)}"

print "Enter your age: "
var age = read(Number)

if (age >= 18) {
    say "You are an adult."
} else {
    say "You are a minor."
}

var temperature = 22

if (temperature > 30) {
    say "It's hot outside!"
} elsif (temperature > 20) {
    say "It's a nice day."
} elsif (temperature > 10) {
    say "It's a bit chilly."
} else {
    say "It's cold — grab a coat!"
}

say "You win!" if (score > 100)
say "Game over." if (lives == 0)
var n = read(Number)
die "Must be positive!" if (n < 0)

var age    = 20
var status = (age >= 18 ? "adult" : "minor")
say status    # adult

var logged_in = false
say "Please log in." unless logged_in

var day = "Monday"

given (day) {
    when ("Saturday") { say "Weekend!" }
    when ("Sunday")   { say "Weekend!" }
    when (/^Mon/)     { say "Start of the work week." }
    else              { say "A regular weekday." }
}

var result = some_function()

with (result) { |val|
    say "Got a result: #{val}"
}
orwith (fallback_function()) { |val|
    say "Got fallback: #{val}"
}
else {
    say "Nothing was returned."
}

var count = 1
while (count <= 5) {
    say "Count: #{count}"
    count++
}

var n = 0
do {
    n++
    say n
} while (n < 3)
# prints: 1, 2, 3

for i in (1..5) {
    say "Step #{i}"
}

var fruits = ["apple", "banana", "cherry"]
for fruit in fruits {
    say "I like #{fruit}"
}

3.times {
    say "Hello!"
}
# prints Hello! three times

5.times { |i|
    say "Iteration #{i}"    # i goes from 0 to 4
}

[10, 20, 30].each { |n|
    say "Value: #{n}"
}

var n = 1
loop {
    say n
    n++
    break if (n > 5)
}

# next: skip to the next iteration
for i in (1..10) {
    next if (i % 2 == 0)    # skip even numbers
    say i
}
# prints: 1, 3, 5, 7, 9

# break: exit the loop early
for i in (1..100) {
    break if (i > 5)
    say i
}
# prints: 1, 2, 3, 4, 5

for i in ((0..20).by(5)) {
    say i    # 0, 5, 10, 15, 20
}

for i in ((10^..1).by(-1)) {
    say i    # 10, 9, 8, ..., 1
}

1.upto(5) { |i| say i }     # 1 2 3 4 5
5.downto(1) { |i| say i }   # 5 4 3 2 1

func greet(name) {
    say "Hello, #{name}!"
}

greet("Alice")    # Hello, Alice!
greet("Bob")      # Hello, Bob!

func add(a, b) {
    (a + b)    # returned automatically
}

func multiply(a, b) {
    return (a * b)    # explicit return
}

var sum     = add(3, 4)         # 7
var product = multiply(3, 4)    # 12
say sum      # 7
say product  # 12

func greet(name = "World", greeting = "Hello") {
    say "#{greeting}, #{name}!"
}

greet()                        # Hello, World!
greet("Alice")                 # Hello, Alice!
greet("Bob", "Good morning")   # Good morning, Bob!

func make_box(width, height, depth) {
    say "Box: #{width} × #{height} × #{depth}"
}

make_box(width: 10, depth: 5, height: 3)
# Box: 10 × 3 × 5

func sum(*numbers) {
    numbers.reduce(0, { |acc, n| (acc + n) })
}

say sum(1, 2, 3)          # 6
say sum(10, 20, 30, 40)   # 100

func square(Number n) {
    (n ** 2)
}

func shout(String s) {
    s.uc + "!!!"
}

say square(5)       # 25
say shout("hello")  # HELLO!!!

func factorial(n) {
    return 1 if (n <= 1)
    (n * factorial((n - 1)))
}

say factorial(5)    # 120
say factorial(10)   # 3628800

func fib(n) is cached {
    return n if (n <= 1)
    (fib((n - 1)) + fib((n - 2)))
}

say fib(10)     # 55
say fib(50)     # 12586269025  (fast, thanks to caching)
say fib(100)    # 354224848179261915075

var double = { |n| (n * 2) }
var square = { |n| (n ** 2) }
var add    = { |a, b| (a + b) }

say double(5)      # 10
say square(4)      # 16
say add(3, 7)      # 10

func make_counter(start = 0) {
    var count = start
    func {
        count++
        say "Count: #{count}"
    }
}

var counter_a = make_counter()
var counter_b = make_counter(10)

counter_a()    # Count: 1
counter_a()    # Count: 2
counter_b()    # Count: 11
counter_a()    # Count: 3  (independent from counter_b)

var fruits   = ["apple", "banana", "cherry"]
var numbers  = [1, 2, 3, 4, 5]
var mixed    = [1, "hello", true, 3.14]
var empty    = []

var fruits = ["apple", "banana", "cherry", "date"]

say fruits[0]     # apple   (first)
say fruits[1]     # banana  (second)
say fruits[-1]    # date    (last)
say fruits[-2]    # cherry  (second to last)

var arr = [1, 2, 3]

arr.push(4)        # add to end   → [1, 2, 3, 4]
arr.pop            # remove last  → [1, 2, 3]
arr.unshift(0)     # add to start → [0, 1, 2, 3]
arr.shift          # remove first → [1, 2, 3]

arr[1] = 99        # replace by index → [1, 99, 3]

var nums = [3, 1, 4, 1, 5, 9, 2, 6]

say nums.length           # 8
say nums.sort             # [1, 1, 2, 3, 4, 5, 6, 9]
say nums.reverse          # [6, 2, 9, 5, 1, 4, 1, 3]
say nums.sum              # 31
say nums.min              # 1
say nums.max              # 9
say nums.uniq             # [3, 1, 4, 5, 9, 2, 6]  (remove duplicates)
say nums.first            # 3
say nums.last             # 6
say nums.first(3)         # [3, 1, 4]

var numbers = [1, 2, 3, 4, 5]
var squared = numbers.map { |n| (n ** 2) }
say squared    # [1, 4, 9, 16, 25]

var names   = ["alice", "bob", "carol"]
var uppered = names.map { .uc }
say uppered    # ["ALICE", "BOB", "CAROL"]

var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

var evens  = numbers.grep { .is_even }
var odds   = numbers.grep { .is_odd }
var big    = numbers.grep { |n| (n > 5) }

say evens    # [2, 4, 6, 8, 10]
say odds     # [1, 3, 5, 7, 9]
say big      # [6, 7, 8, 9, 10]

var numbers = [1, 2, 3, 4, 5]

var sum     = numbers.reduce(0, { |acc, n| (acc + n) })
var product = numbers.reduce(1, { |acc, n| (acc * n) })

say sum       # 15
say product   # 120

["red", "green", "blue"].each { |color|
    say "Color: #{color}"
}

["a", "b", "c"].each_with_index { |val, i|
    say "#{i}: #{val}"
}
# 0: a
# 1: b
# 2: c

var words = ["Hello", "World", "from", "Sidef"]
say words.join(" ")     # Hello World from Sidef
say words.join(", ")    # Hello, World, from, Sidef
say words.join          # HelloWorldfromSidef

# word arrays with %w notation (shorthand for array of strings)
var fruits = %w(apple banana cherry)
# same as: ["apple", "banana", "cherry"]

var arr = [10, 20, 30, 40, 50]

say arr[1..3]      # [20, 30, 40]  (indices 1 to 3)
say arr[0..^3]     # [10, 20, 30]  (indices 0 to 2, exclusive end)
say arr[2..]       # [30, 40, 50]  (from index 2 to the end)

var fruits = ["apple", "banana", "cherry"]

say fruits.contains("banana")    # true
say fruits.contains("grape")     # false
say fruits.index("cherry")       # 2  (position of element)

say (1..5).to_a           # [1, 2, 3, 4, 5]
say (1..10).grep { .is_prime }.to_a    # [2, 3, 5, 7]

var person = Hash(
    name => "Alice",
    age  => 30,
    city => "London",
)

say person{:name}    # Alice
say person{:age}     # 30
say person{:city}    # London

person{:email} = "[email protected]"    # add new key
person{:age}   = 31                     # update existing key

say person.has(:name)       # true
say person.has(:phone)      # false

person.delete(:city)

say person.keys      # ["name", "age", "email"]  (order may vary)
say person.values    # ["Alice", 31, "[email protected]"]
say person.len       # 3

person.each { |key, value|
    say "#{key}: #{value}"
}

# Count word frequencies
var text  = "the cat sat on the mat the cat"
var words = text.split(" ")
var freq  = Hash()

words.each { |word|
    freq{word} := 0    # set to 0 if not yet defined
    freq{word}++
}

freq.keys.sort.each { |word|
    say "#{word}: #{freq{word}}"
}
# cat: 2
# mat: 1
# on:  1
# sat: 1
# the: 3

var s = "Hello, World!"

say s.uc            # HELLO, WORLD!  (uppercase)
say s.lc            # hello, world!  (lowercase)
say s.length        # 13
say s.reverse       # !dlroW ,olleH
say s.trim          # removes leading/trailing whitespace

say s.contains("World")      # true
say s.begins_with("Hello")   # true
say s.ends_with("!")         # true
say s.index("World")         # 7  (position where it starts)

var text = "I like cats and cats like me."

say text.sub("cats", "dogs")          # I like dogs and cats like me.  (first only)
say text.gsub("cats", "dogs")         # I like dogs and dogs like me.  (all)
say text.gsub(/cats?/, "animals")     # with regex pattern

var csv = "Alice,30,London"
var parts = csv.split(",")
say parts[0]    # Alice
say parts[1]    # 30
say parts[2]    # London

say parts.join(" | ")    # Alice | 30 | London

var s = "Hello, World!"

say s[0..4]       # Hello
say s[7..11]      # World
say s[0, 5]       # Hello  (start, length)

var email = "[email protected]"

if (email =~ /\w+@\w+\.\w+/) {
    say "Valid email format."
}

# Capture parts of a match
var date  = "2024-03-15"
var match = date.match(/(\d{4})-(\d{2})-(\d{2})/)
say "Year:  #{match[0]}"    # 2024
say "Month: #{match[1]}"    # 03
say "Day:   #{match[2]}"    # 15

say "42".to_i       # converts string to integer: 42
say "3.14".to_r     # converts string to number:  3.14
say 42.to_s         # converts number to string: "42"
say 255.to_s(16)    # convert to hex string: "ff"
say 255.to_s(2)     # convert to binary string: "11111111"

# Read the entire file as a string
var content = File("myfile.txt").read
say content

# Read line by line (memory efficient for large files)
File("myfile.txt").each_line { |line|
    say line.trim
}

# Read all lines into an array
var lines = File("myfile.txt").lines
say "File has #{lines.len} lines."

# Write (overwrites any existing content)
File("output.txt").write("Hello, File!\n")

# Append (adds to the end without erasing)
File("output.txt").append("Second line.\n")

var f = File("data.txt")

if (f.exists) {
    say "File found! Size: #{f.size} bytes."
    var content = f.read
} else {
    say "File not found."
}

# Save a shopping list to a file and read it back
var list = ["apples", "bread", "milk", "eggs"]
File("shopping.txt").write(list.join("\n") + "\n")

say "Saved shopping list. Reading it back:"
File("shopping.txt").each_line { |line|
    say "- #{line.trim}"
}

try {
    var result = (10 / 0)
    say result
}
catch { |error|
    say "An error occurred: #{error}"
}

func divide(a, b) {
    die "Cannot divide by zero!" if (b == 0)
    (a / b)
}

try {
    say divide(10, 2)    # 5
    say divide(10, 0)    # raises error
}
catch { |msg|
    say "Error: #{msg}"
}

var x = 5
assert(x > 0, "x must be positive")
assert_eq(x, 5, "x must be 5")
assert_ne(x, 0, "x must not be zero")

say 17.is_prime           # true
say 10.primes             # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
say primes(100, 150)      # all primes between 100 and 150
say 1000.prime            # 7919  (the 1000th prime)
say prime_count(10**6)    # 78498 (number of primes up to a million)

say factor(360)            # [2, 2, 2, 3, 3, 5]
say factor_exp(360)        # [[2,3],[3,2],[5,1]]  (prime, exponent pairs)
say divisors(36)           # [1, 2, 3, 4, 6, 9, 12, 18, 36]
say euler_phi(36)          # 12  (Euler's totient)

say gcd(48, 18)    # 6
say lcm(4,  6)     # 12

say (2 ** 1000)           # a 302-digit number
say 100.factorial         # a 158-digit number
say (10 ** 100)           # a googol

say Num.pi              # π ≈ 3.14159265358979...
say Num.e               # e ≈ 2.71828182845904...
say sqrt(2)             # √2 ≈ 1.41421356237309...
say sin(Num.pi / 2)     # 1
say cos(0)              # 1
say log(Num.e)          # 1
say (2.718281828).log   # ≈ 1  (natural log)

say 255.to_s(2)     # "11111111"  (binary)
say 255.to_s(16)    # "ff"        (hexadecimal)
say 255.to_s(8)     # "377"       (octal)
say "ff".to_i(16)   # 255         (hex string to integer)

func celsius_to_fahrenheit(c) {
    ((c * 9/5) + 32)
}

func fahrenheit_to_celsius(f) {
    ((f - 32) * 5/9)
}

print "Enter temperature in Celsius: "
var c = read(Number)

say "#{c}°C = #{celsius_to_fahrenheit(c).round(2)}°F"
say "#{c}°C = #{(c + 273.15).round(2)} K"

for i in (1..100) {
    say (
        ((i % 15) == 0) ? "FizzBuzz" :
        ((i % 3)  == 0) ? "Fizz"     :
        ((i % 5)  == 0) ? "Buzz"     :
        i
    )
}

func calculate(a, op, b) {
    given (op) {
        when ("+") { (a + b) }
        when ("-") { (a - b) }
        when ("*") { (a * b) }
        when ("/") {
            die "Cannot divide by zero!" if (b == 0)
            (a / b)
        }
        else { die "Unknown operator: #{op}" }
    }
}

print "First number:  "
var a = read(Number)
print "Operator (+, -, *, /): "
var op = read(String)
print "Second number: "
var b = read(Number)

try {
    say "Result: #{calculate(a, op, b)}"
}
catch { |msg|
    say "Error: #{msg}"
}

var secret = (1..100).rand    # random number between 1 and 100
var guesses = 0

say "I'm thinking of a number between 1 and 100."
say "Can you guess it?"

loop {
    print "Your guess: "
    var guess = read(Number)
    guesses++

    if (guess < secret) {
        say "Too low! Try higher."
    } elsif (guess > secret) {
        say "Too high! Try lower."
    } else {
        say "Correct! You got it in #{guesses} guess#{(guesses == 1 ? '' : 'es')}!"
        break
    }
}

func stats(data) {
    var n    = data.len
    var mean = (data.sum / n)

    var sorted   = data.sort
    var median   = (n.is_odd
        ? sorted[n / 2]
        : ((sorted[(n/2) - 1] + sorted[n/2]) / 2)
    )

    var variance = (data.map { |x| ((x - mean)**2) }.sum / n)
    var std_dev  = variance.sqrt

    Hash(
        count   => n,
        sum     => data.sum,
        mean    => mean.round(4),
        median  => median,
        min     => data.min,
        max     => data.max,
        std_dev => std_dev.round(4),
    )
}

var data = [4, 8, 15, 16, 23, 42]
var s    = stats(data)

say "Count:   #{s{:count}}"
say "Sum:     #{s{:sum}}"
say "Mean:    #{s{:mean}}"
say "Median:  #{s{:median}}"
say "Min:     #{s{:min}}"
say "Max:     #{s{:max}}"
say "Std Dev: #{s{:std_dev}}"

# Method 1: Simple recursive with caching
func fib(n) is cached {
    return n if (n <= 1)
    (fib((n - 1)) + fib((n - 2)))
}

say "First 15 Fibonacci numbers:"
say (0..14).map { |n| fib(n) }

# Method 2: Iterative
func fib_sequence(count) {
    var result = [0, 1]
    while (result.len < count) {
        result.push((result[-1] + result[-2]))
    }
    result.first(count)
}

say fib_sequence(20)

say "=== Prime Number Explorer ==="
say ""

# First 20 primes
say "First 20 primes:"
say 20.primes
say ""

# Check if numbers are prime
[2, 7, 13, 25, 97, 100, 101].each { |n|
    var status = n.is_prime ? "prime" : "not prime"
    say "#{n} is #{status}"
}
say ""

# Factorize some numbers
[12, 60, 100, 360, 2310].each { |n|
    say "#{n} = #{factor(n).join(' × ')}"
}
say ""

# Twin primes (pairs that differ by 2)
say "Twin prime pairs up to 100:"
var prev = 2
primes(3, 100).each { |p|
    say "(#{prev}, #{p})" if ((p - prev) == 2)
    prev = p
}

# Count and display word frequencies from a string

var text = <<'END'
To be or not to be that is the question
Whether tis nobler in the mind to suffer
The slings and arrows of outrageous fortune
Or to take arms against a sea of troubles
END

var words = text.lc.split(/\W+/).grep { .len > 0 }
var freq  = Hash()

words.each { |w|
    freq{w} := 0
    freq{w}++
}

say "Word frequencies (sorted by count, descending):"
say "=" * 35

freq.keys
    .sort_by { |k| -freq{k} }
    .first(10)
    .each { |word|
        var count = freq{word}
        var bar   = "█" * count
        say "#{ '%-12s' % word } #{bar} (#{count})"
    }

func sierpinski(n) {
    var rows = ["*"]
    n.times { |i|
        var sp   = (" " * (2**i))
        rows = (rows.map { |r| (sp + r + sp) } +
                rows.map { |r| (r + " " + r) })
    }
    rows.join("\n")
}

say sierpinski(4)