VeeDeltaVee

05-04-2020 16:02:34:["lsp#register_server", "server registered", "vim-language-server"]
05-04-2020 16:02:35:["lsp#register_server", "server already registered", "vim-language-server"]
05-04-2020 16:02:35:["lsp#register_server", "server registered", "vim-language-server"]
05-04-2020 16:02:35:["vim-lsp signs enabled"]
05-04-2020 16:02:35:["vim-lsp highlighting enabled"]
05-04-2020 16:02:35:["s:on_text_document_did_open()", 1, "startify", "C:\\Users\\Versha\\scoop\\apps\\neovim-nightly\\current\\bin", ""]
05-04-2020 16:02:35:["s:on_text_document_did_change()", 1]
05-04-2020 16:02:35:["s:send_didchange_queue() will be triggered"]
05-04-2020 16:02:36:["s:send_event_queue()"]
05-04-2020 16:02:39:["s:on_text_document_did_close()", 1]

VeeDeltaVee

use rayon::prelude::*;

const GRID_SIZE: usize = 300;

fn find_hundreds_digit(value: i64) -> i64 {
    (value / 100) % 10
}

fn find_grid_cell_value(x: usize, y: usize, serial: i64) -> i64 {
    // internals use (0, 0) as origin

VeeDeltaVee

#[macro_use] extern crate scan_fmt;

use std::io::BufRead;

#[derive(Debug)]
struct Star {
    position: (i64, i64),
    velocity: (i64, i64)
}

VeeDeltaVee

use std::collections::VecDeque;

#[derive(Debug)]
struct ParseInputError {}

/// Parses a line of input to give (number of players, largest marble used)
fn parse_input(input: &str) -> Result<(usize, usize), ParseInputError> {
    let numbers: Vec<_> = input
        .trim()
        .split_whitespace()

VeeDeltaVee

#[derive(Debug)]
pub struct Tree {
    children: Vec<Tree>,
    metadata: Vec<i64>,
}

impl Tree {
    fn new() -> Tree {
        Tree {
            children: Vec::new(),

VeeDeltaVee

use std::str::FromStr;
use std::num::ParseIntError;
use std::io::Read;

#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd)]
struct Matrix<T> {
    rows: usize,
    columns: usize,
    buf: Vec<T>,
}

VeeDeltaVee

use std::io;

fn characters_match(a: char, b: char) -> bool {
    return a.to_ascii_lowercase() == b.to_ascii_lowercase() &&
        (a.is_ascii_lowercase() && b.is_ascii_uppercase() || a.is_ascii_uppercase() && b.is_ascii_lowercase())
}

fn process_polymer_reaction_step(polymer: &mut String) -> usize {
    let mut num_changes = 0;

VeeDeltaVee

extern crate regex;
#[macro_use] extern crate lazy_static;

use std::io::Read;
use std::collections::BTreeMap;
use regex::Regex;

#[derive(Debug)]
struct GuardProfile {
    id: usize,                          // The guard id

VeeDeltaVee

use std::io::Read;

fn common_str(id1: &str, id2: &str) -> String {
    let mut common= String::new();

    for (char1, char2) in id1.chars().zip(id2.chars()) {
        if char1 == char2 {
            common.push(char1);
        }
    }

VeeDeltaVee

use std::collections::BTreeMap;
use std::io::Read;

fn contains_n_of_any_letter(id: &str, n: i64) -> bool {
    let mut frequency_count = BTreeMap::new();

    for c in id.chars() {
        *frequency_count.entry(c).or_insert(0) += 1;
    }