robert-king

struct Unset;

struct PizzaBuilder<Dough, Topping> {
    dough: Dough,
    topping: Topping,
}

impl<T> PizzaBuilder<Unset, T> {
    fn with_dough(self, dough: &str) -> PizzaBuilder<String, T> {
        PizzaBuilder {

robert-king

#![feature(type_changing_struct_update)]
use std::marker::PhantomData;

struct Set;
struct Unset;

struct PizzaBuilder<Dough, Topping> {
    dough: Option<String>,
    topping: Option<String>,
    state: PhantomData<(Dough, Topping)>,

robert-king

use std::marker::PhantomData;

use typemap::{Key, TypeMap};

struct EventListenerKey<E>(PhantomData<E>);

trait EventListner<E>: FnMut(&E) -> () + 'static {}

impl<F, E> EventListner<E> for F where F: FnMut(&E) -> () + 'static {}

robert-king

"""
Rusty Rob
https://x.com/robertkingNZ

For this hard problem I discovered that an innovative linear solution exists and thought it was worth sharing.

Problem statement
https://www.facebook.com/codingcompetitions/hacker-cup/2020/qualification-round/problems/D2

TLDR Problem statement:

robert-king

/*
Problem E: Wildcard Submissions
https://www.facebook.com/codingcompetitions/hacker-cup/2024/round-1/problems/E
I didn't participate but I coded up the solution to E after reading over the contest analysis
*/

use rayon::prelude::*;
use std::io::{stdin, BufRead};

const MODULO: u64 = 998_244_353;

robert-king

struct Node {
    next: Option<Box<Node>>,
    val: i32,
}

impl Node {
    fn new(val: i32) -> Self {
        Node { next: None, val }
    }

robert-king

use std::hash::Hash;
use std::{collections::HashMap, thread, time::Duration};

fn factorial(n: i32) -> i32 {
    if n <= 1 {
        return 1;
    }
    thread::sleep(Duration::from_millis(100));
    factorial(n - 1).wrapping_mul(n)
}

robert-king

#![allow(dead_code)]

/*
we use hashmaps for the linkedlist to sidestep the borrow checker.
we use proptest strategy to generate series of operations across the linkedlist and compare to a VecDeque for correctness.
We can add subtle bugs and proptest manages to catch them 
and shrink down to a minimal reproduction which we can then copy and paste to create a new test case.

PROPTEST_CASES=1000000 PROPTEST_MAX_SHRINK_ITERS=100000000 cargo test --release
cargo test copy_test_case

robert-king

/*
- Blazing fast, highly accurate cheating detection algorithm
- by Robert King, https://www.linkedin.com/in/robertkingnz/
- Youtube walkthrough: https://youtu.be/CnIQkIseLGs
- X https://x.com/robertkingNZ

- BACKGROUND
- The Google Code Jam team presented their 90% accurate algorithm after google code jam 2021.
- During the contest, Rob discovered a ~100% accurate algorithm and so thought it was worth sharing.

robert-king

// https://youtu.be/zhF-L_BgCHo

use std::sync::{mpsc::channel, Arc, Mutex};
use std::thread;
use std::time::Instant;

fn is_prime(n: i32) -> bool {
    if n < 2 {
        return false;
    }