print("Hello World!")
var doors = List.repeat(100, false)
for i in 0...99: {
for j in i...99 by i + 1: {
doors[j] = !doors[j]
}
}
# The type must be specified since the List starts off empty.
var open_doors: List[Integer] = []
doors.each_index(|i|
if doors[i]: {
open_doors.push(i + 1)
}
)
print("Open doors: {0}.".format(open_doors))
enum TreeObject {
TreeValue(String),
TreeList(TreeObject...)
define as_string: String {
match self: {
case TreeValue(v):
return v
case TreeList(l):
var result = "["
var size = l.size() - 1
for i in 0...size: {
result = "{0}{1}".format(result, l[i].as_string())
if i != size: {
result = result ++ " "
}
}
return result ++ "]"
}
}
}
stdout.write("Here's a JSON-like enum value as a string: ")
print(
TreeList(
TreeList(
TreeValue("abc"),
TreeValue("def")
),
TreeValue("1"),
TreeValue("2"),
TreeList(
TreeList(
TreeValue("0")
)
)
).as_string()
)
var math_ops = ["+" => (|a: Integer, b: Integer| a + b),
"-" => (|a, b| a - b),
"*" => (|a, b| a * b),
"/" => (|a, b| a / b)]
define rpn(input: String): Result[String, List[Integer]]
{
var values = input.split(" ").reject(|r| r.is_space() )
var stack: List[Integer] = []
for i in 0...values.size() - 1: {
var v = values[i]
match v.parse_i(): {
case Some(number):
stack.push(number)
case None:
if stack.size() < 2: {
return Failure("Stack underflow.")
}
var right = stack.pop()
var left = stack.pop()
try: {
var op_fn = math_ops[v]
var op_value = op_fn(left, right)
stack.push(op_value)
except KeyError:
return Failure("Invalid operation {0}.".format(v))
except DivisionByZeroError:
return Failure("Attempt to divide by zero.")
}
}
}
return Success(stack)
}
var lines = [
"1 2 3 4 * + -",
"2 2 2 2 * *",
"*",
"1 2 ?"
]
lines.each(|l| print("{0}: {1}".format(l, rpn(l)) ) )
define factorial_co(co: Coroutine[Integer, Unit], num: Integer) {
var f = 1
for i in 2...num + 1: {
co.yield(f)
f *= i
}
}
import (Random) random
var task_count = 4
var max = 5
var r = Random()
var id_list: List[Integer] = []
var rng_list: List[Integer] = []
var last_round = 0
for i in 1...task_count: {
var rng = r.between(1, max)
if rng > last_round: {
last_round = rng
}
rng_list.push(rng)
id_list.push(i)
}
last_round += 1
var coro_list = rng_list.map(|rng| Coroutine.build_with_value(factorial_co, rng) )
var num_left = coro_list.size()
var round = 1
var to_drop = 0
while num_left: {
print("Round {0} with {1} tasks.".format(round, num_left) )
for i in 0...num_left - 1: {
var task = coro_list[i]
match task.resume(): {
case Some(s):
print("Task {0}: factorial({1}) = {2}."
.format(id_list[i], round, s) )
case None:
to_drop += 1
}
}
if to_drop: {
var i = 0
while i < coro_list.size(): {
if coro_list[i].is_waiting() == false: {
coro_list.delete_at(i)
id_list.delete_at(i)
else:
i += 1
}
}
num_left -= to_drop
to_drop = 0
}
round += 1
if round == last_round: {
break
}
print("")
}