jaguilar

function CLAMP(min, max, n) {
  if (n < min) return min;
  if (n > max) return max;
  return n;
}

function MEETPROB(n) {
  return CLAMP(0.05, 0.95, 1-((n-1)/20.0));
}

jaguilar

hedgemony = (input) ->
  lines = input.match(/[^\r\n]+/g);
  numTests = parseInt(lines[0])
  formatOutput i, solve lines[2*i] for i in [1..numTests]

solve = (line) ->
  heights = (parseFloat s for s in line.split(" "))
  n = 1
  while n < heights.length - 1
    average = (heights[n-1] + heights[n+1]) / 2.0

jaguilar

// Today we learn about the insane things that can be done with variadic templates.

template <int N> struct A {
  template <typename O, typename R, typename... FArgs, typename... TArgs, typename... Args>
  R operator()(O* o, R (O::*f)(FArgs...), const std::tuple<TArgs...>& t, Args... args) {
    return A<N-1>()(o, f, t, std::get<N>(t), args...);
  }
};

template <> struct A<-1> {

jaguilar

import sublime, sublime_plugin
import subprocess

class ClangFormatCommand(sublime_plugin.TextCommand):
  def run(self, edit):
    r = sublime.Region(0, self.view.size())
    try:
      p = subprocess.Popen(
          ['clang-format', '--style', 'Google'],
          stdin=subprocess.PIPE,

jaguilar

// Why does this work . . .

trait Additive: Add<Self, Self> {}

fn sum<T, U: Zero + Additive>(seq: &[T], f: &fn(&T) -> U) -> U {
    let mut u: U = Zero::zero();
    for seq.each |x| { u += f(x); };
    u
}

jaguilar

// I hereby release this code to the public domain.

// Substitutes for placeholders in a string.
// Ex. sub("I am a {0} monkey.", "silly") -> "I am a silly monkey."
function sub(s) {
  var args = arguments;
  return s.replace(/{(\d+)}/g, function(match, number) { 
    var n = parseInt(number);
    return typeof args[n+1] != 'undefined'
    ? args[n+1]

jaguilar

template <template <typename ...> class Container,
          typename F,
          typename InType,
          typename OutType =
              typename std::result_of<F(InType)>::type>
Container<OutType> c_transform(const Container<InType>& in,
                               const F& f) {
  Container<OutType> out;
  auto it = std::inserter(out, out.end());
  for (const auto& e : in) {

jaguilar

Ingredients:

3-4 cups of coarse bread crumbles (best made using stale bread that's been left out for 1/2 week)
2 cups chopped onion
1 cup finely chopped celery
1lb cheap, high-fat sausage meat -- think Jimmy Dean breakfast sausage
1-2 cups chicken broth
1/2-1 stick of butter
1 1/2 tsp sage
1/2 tsp thyme

jaguilar

Problem Statement

• Allocate resources from one server to work on another.
• Weaken and grow first, before beginning to hack.
• Allocate resources toward the most efficient available task, subject to some allowances for early progression.
• Minimize RAM usage (scheduling overhead of around 30GB).

Overview

I designed a system with three main components:

jaguilar

import {getHosts, getAllHosts, schedule} from "hack-dist.js";

const target = args[0];
const numBatchWeaken = 9;
const numBatchGrow = 9;
const numBatchHack = 3;
export const allowedRam = 1000;

function killAllMatching(...args) {
    getAllHosts().forEach(h => {