aita

use std::{cmp::Ordering, ops::Not};

pub struct RBTree<K>
where
    K: Ord,
{
    root: Option<Box<Node<K>>>,
}

impl<K> RBTree<K>

aita

#!/bin/bash

echo "Install packages"
yay -Syu \
    --needed \
    --norebuild \
    --noredownload \
    --answerclean None \
    --answerdiff None \
    --answeredit None \

aita

#!/usr/bin/env bash

kubenv () {
    if [[ -z "$1" ]]; then
        cat <<EOF >/dev/stderr
Usage: kubenv CONTEXT_NAME
EOF
        return 1
    fi

aita

package main

import (
	"fmt"
)

func prefixTable(p string) []int {
	f := make([]int, len(p))
	i, j := 1, 0
	for i < len(p) {

aita

#ifdef GL_ES
precision mediump float;
#endif

uniform vec2 u_resolution;
uniform float u_time;

#define PI 3.14159265358979323846

vec2 rotate2D(vec2 _st, float _angle){

aita

class Node:
    def __init__(self, t, is_leaf=True):
        self.t = t
        self.is_leaf = is_leaf
        self.keys = []
        self.children = []

    def is_full(self):
        return len(self.keys) == 2 * self.t - 1

aita

import random


class Node:
    def __init__(self, key, priority):
        self.key = key
        self.priority = priority
        self.parent = None
        self.left = None
        self.right = None

aita

from enum import Enum, auto


class Color(Enum):
    RED = auto()
    BLACK = auto()


class Node:
    def __init__(self, key):

aita

use rand;

fn fisher_yates_shuffle<T: PartialOrd>(v: &mut [T]) {
    let len = v.len();
    for i in (1..v.len()).rev() {
        let j = rand::random::<usize>() % (i + 1);
        v.swap(i, j);
    }
}

aita

fn binary_search<T: PartialOrd>(v: &[T], x: &T) -> usize {
    let mut l = 0;
    let mut r = v.len();
    while l < r {
        let mid = (l + r) / 2;
        if *x < v[mid] {
            r = mid
        } else {
            l = mid + 1
        }