rosalogia

#include <bits/stdc++.h>
#define N 1000010
using namespace std;
typedef long long int ll;

vector<ll> graph[N];
set<ll> seen;
ll min_cost = LLONG_MAX;

void dfs(ll costs[], ll r) {

rosalogia

#include <iostream> // For input/output
using namespace std;

// The merge function is where the sorting actually happens
// int arr[] is the array we're passing in
// int l is the index of the array that the left "chunk" begins at
// int m is the index of the array that the left "chunk" ends at, whereas the right "chunk" ends at m + 1
// int r is the index of the array that the right "chunk" /ends/ at
void merge(int arr[], int l, int m, int r) {
    // Here we compute the size of the two "chunks"

rosalogia

#r "nuget: FSharp.Json"
open FSharp.Json
open System.IO

type SubSection =
    { Name: string
    ; Weight: float
    ; ProblemRange: int * int }

type Section =

rosalogia

use std::collections::HashMap;

pub fn mean(values: &[i32]) -> f64 {
    let mut sum = 0.0;

    for x in values {
        sum += *x as f64;
    }

    sum / values.len() as f64

rosalogia

#r "nuget: FSharp.Data"
open FSharp.Data

let args = System.Environment.GetCommandLineArgs()

let flags =
    if args.Length > 3 then
        args.[2..(args.Length - 2)]
    else
        [||]

rosalogia

    private static <Key extends Comparable<Key>, Value> boolean isRed(Node<Key, Value> root) {
        return root != null && root.isRed;
    }

    private static <Key extends Comparable<Key>, Value> int size(Node<Key, Value> root) {
        if (root == null) return 0;
        return 1 + size(root.left) + size(root.right);
    }

    private static <Key extends Comparable<Key>, Value> Node<Key, Value> leftRotate(Node<Key, Value> root) {

rosalogia

#r "nuget: FSharp.Data"
open FSharp.Data
open System.IO

let args = System.Environment.GetCommandLineArgs()
let first = int <| args.[2]
let last = int <| args.[3]

let fetchPageAsync i =
    async {

rosalogia

-- The relation R defined as a function:
-- Takes two integers and returns true
-- if aRb and false otherwise
r :: Integer -> Integer -> Bool

-- Why gcd? The relation r can be 
-- redefined in a way that's more
-- convenient to represent computationally:
-- aRb if the numerator and denominator
-- of the simplest form of a/b are both odd.

rosalogia

module List =
    // Some code for generating permutations of a list
    // Please disregard it, I copied it off the internet :)
    let rec permutations l =
        let rec aux = function
            | []      -> seq [List.empty]
            | x :: xs -> Seq.collect (insertions x) (aux xs)
        aux l |> Seq.toList
    and insertions x = function
        | []             -> [[x]]

rosalogia

let step (x, y) =
    (* Match on a random integer between 0 and 3
     * incrementing or decrementing either x or y
     * depending on the result. The pattern matching
     * is not exhaustive, but because we know
     * Random.int 4 can only return a number between
     * 0 and 3, this is okay. *)
    match Random.int 4 with
    | 0 -> (x + 1, y)
    | 1 -> (x - 1, y)