sjolsen

"""An example of how to design Factorio factories using linear algebra.

This program computes the number of oil refineries, chemical plants, and
assembly machine 2s needed to convert an abundant supply of crude oil and water
into 1.33 rocket fuel per second, the rate needed to satisfy one rocket silo in
the base game, not including modules.

Two abstract vector spaces are constructed: one representing products, and one
representing recipes. Each recipe is associated with a balanced equation over
products. By expressing this association as a matrix, we can express the

sjolsen

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

int write_all(int fd, const void *buf, size_t count) {
  const char *cbuf = (const char *)buf;

sjolsen

import collections
import dataclasses
import sys
from typing import Iterable, Self


IGNORED_WORDS: frozenset[str] = frozenset([
    'adv',
    'dis',
    'eds',

sjolsen

(defclass callable-class (standard-class function)
  ()
  (:metaclass sb-mop:funcallable-standard-class))

(defmethod sb-mop:validate-superclass ((class callable-class) superclass)
  (or (typep superclass 'callable-class)
      (typep superclass 'standard-class)))

(defmethod initialize-instance :after ((class callable-class) &rest rest &key &allow-other-keys)
  (declare (ignore rest))

sjolsen

import apt
import networkx as nx


def is_root(pkg: apt.package.Package) -> bool:
    if not pkg.is_installed:
        return False
    if not pkg.is_auto_installed:
        return True
    if pkg.essential:

sjolsen

module Grammar where
  open import Category.Applicative
  open import Data.Char using (Char)
  open import Data.List using (List)
  open import Data.List.NonEmpty using (List⁺; map; foldl₁; fromList)
  open import Data.Maybe using (from-just)
  open import Data.Nat using (ℕ; _+_; _*_)
  open import Data.String using (String; toList)
  open import Data.Unit
  open import Function

sjolsen

sjolsen

import sys
from typing import FrozenSet, Iterable, Iterator, List, NamedTuple, NewType, Sequence, Set

from frozendict import frozendict
from multiset import FrozenMultiset

# Text munging

def normalize(s: str) -> str:
    return ''.join(c.lower() for c in s if c.isalnum())            

sjolsen

use futures::executor::*;
use futures::future::*;
use futures::task::*;
use futures_util::pin_mut;
use std::pin::*;

async fn use_me(i: i32) -> i32 {
    i
}

sjolsen

#include <charconv>
#include <iostream>
#include <string>
#include <system_error>

std::string to_hex(uint64_t val) {
  char buf[16];
  auto [end, e] = std::to_chars(std::begin(buf), std::end(buf), val, 16);
  if (e != std::errc()) {
    throw std::system_error(std::make_error_code(e));