orlp

Target	ptr	8	16	32	64	128
aarch64-apple-darwin	✅	✅	✅	✅	✅	✅
aarch64-apple-ios	✅	✅	✅	✅	✅	✅
aarch64-apple-ios-macabi	✅	✅	✅	✅	✅	✅
aarch64-apple-ios-sim	✅	✅	✅	✅	✅	✅
aarch64-apple-tvos	✅	✅	✅	✅	✅	✅
aarch64-apple-tvos-sim	✅	✅	✅	✅	✅	✅
aarch64-apple-visionos	✅	✅	✅	✅	✅	✅
aarch64-apple-visionos-sim	✅	✅	✅	✅	✅	✅

orlp

use std::collections::HashMap;
use rand::{Rng, seq::SliceRandom};
use std::time::Instant;

fn rand_input(rng: &mut impl Rng) -> String {
    let theirs = ["A", "B", "C"].choose(rng).unwrap();
    let ours = ["X", "Y", "Z"].choose(rng).unwrap();
    format!("{theirs} {ours}\n")
}

orlp

orlp

from collections import defaultdict
import sys
import pulp

class keydefaultdict(defaultdict):
    def __missing__(self, key):
        ret = self[key] = self.default_factory(key)
        return ret

def horiz_disjoint(xvals):

orlp

import numpy as np
from collections import deque

class VoseAliasMethod:
    # Vose's Alias Method as described at https://www.keithschwarz.com/darts-dice-coins/.
    def __init__(self, weights):
        pmf = weights / np.sum(weights)
        self.n = pmf.shape[0]
        self.prob = np.zeros(self.n, dtype=np.float64)
        self.alias = np.zeros(self.n, dtype=np.int64)

orlp

use std::collections::{HashSet, HashMap};

#[derive(Clone, Debug)]
struct CountBucket {
    prev: i64,
    next: i64,
    indices: HashSet<usize>,
}

orlp

use slotmap::{SlotMap, SecondaryMap, new_key_type, Key};
use std::collections::HashSet;

new_key_type! {
    struct BucketKey;
}

new_key_type! {
    struct IndexKey;
}

orlp

import collections
import numpy as np
import scipy.sparse
import scipy.sparse.linalg
import sys
import imageio
import io
import base64

class MazeJudge:

orlp

import numpy as np

def expected_time_to_solve(N):
    A = np.zeros((4*(N+2), 4*(N+2)))
    # (n, forward) => (4n + 0), (n, backward) => (4n + 1), (n, inside) => (4n + 2), (n, facewall) => (4n + 3)
    for i in range(4*(N+2)):
        if i < 4:
            A[i,4] = 1
        elif i >= 4*(N+1):
            A[i,i] = 1

orlp

import itertools as it
import networkx as nx
import math

K = 3
N = math.factorial(K) + K - 1

print("Constructing sets")
left = list(it.permutations(range(N)))
right = sorted({(p[:cloth] + p[cloth+K:], cloth) for p, cloth in it.product(it.permutations(range(N)), range(N-K+1))})