Skip to content
  • lol
  • lel
  • kek
  • top kek
  • rotfl
  • lmao
  • yeah, no
  • no.
  • what
  • wat

Factorio basic rules

  1. Don't be a dick
    • a. The player that hosts has to retrieve the most recent save
    • b. The player that originally hosted has to replace the old save with the new one at the end of the match
    • c. The player whose responsibility is to replace the old save can delegate the job to someone else upon agreement
  2. Destroying property requires consent to those that put it down
  3. Don't kill other players
  4. Autosave period must be set to 15 minutes
create view total_driving_slots as (
select week_day,
time,
count(id) as total_count
from driving_slots
group by week_day, time
);
create view free_driving_slots as (
select week_day,
function signin_required($login_page, $fn) {
return function($db) use ($fn, $login_page) {
if (array_key_exists('user_id', $_SESSION))
$fn($db);
else engine\redirect($login_page);
};
}
namespace detail {
template<typename It>
It partition(It begin, It end) {
if (begin == end) return end;
auto pivot = *(end - 1);
auto left = begin; // left partion past the end
for (auto right = begin; right != end; ++right) {
if (*right <= pivot) {
std::iter_swap(left, right);
#!/usr/bin/python
import ninja_syntax
import itertools
import os
import fnmatch
import re
import sys
import argparse

The asymmetries of C++

This is lighthearted collection of asymmetries of the C++ language. This is not, in any way, intended as a critic.


Partial specialization is allowed for class templates but not for function templates

§14.5.5 [temp.class.spec] describes the semantic and syntax for class template partial specialization such as, given:

-- Write a program that outputs all possibilities to put + or - or nothing
-- between the numbers 1, 2, ..., 9 (in this order) such that the result is
-- always 100. For example: 1 + 2 + 34 – 5 + 67 – 8 + 9 = 100.
import Control.Monad (replicateM)
ints :: [String]
ints = map (\i -> [i]) ['1'..'9']
inbetweens :: [[String]]
type alias Unit = Float
type Vec2 = Vec2 Unit Unit
(|+|) : Vec2 -> Vec2 -> Vec2
(Vec2 ax ay) |+| (Vec2 bx by) = Vec2 (ax + bx) (ay + by)
negate : Vec2 -> Vec2
negate (Vec2 x y) = Vec2 (-x) (-y)
(|-|) : Vec2 -> Vec2 -> Vec2
#include <iostream>
#include <fstream>
#include <map>
#include <stdexcept>
#include <vector>
namespace a8 {
// aliases
using word = std::string;
Something went wrong with that request. Please try again.