initial commit

Author: frol

.gitignore

@@ -0,0 +1,10 @@
+*.class
+*-gcc
+*-clang
+*-rs
+*-nim
+*.jar
+*.kexe
+*-swift
+*.pyc
+nimcache

Main.java

@@ -0,0 +1,124 @@
+import java.util.*;
+import java.lang.*;
+
+class SplitResult {
+    SplitResult(Node lower, Node equal, Node greater) {
+        this.lower = lower;
+        this.equal = equal;
+        this.greater = greater;
+    }
+
+    public Node lower;
+    public Node equal;
+    public Node greater;
+}
+
+class NodePair {
+    NodePair(Node first, Node second) {
+        this.first = first;
+        this.second = second;
+    }
+
+    public Node first;
+    public Node second;
+}
+
+class Node {
+    public static Random random = new Random();
+
+    Node(int x) {
+        this.x = x;
+    }
+
+    int x;
+    int y = random.nextInt();
+    Node left = null;
+    Node right = null;
+
+    public static Node merge(Node lower, Node greater) {
+        if (lower == null)
+            return greater;
+
+        if (greater == null)
+            return lower;
+
+        if (lower.y < greater.y) {
+            lower.right = merge(lower.right, greater);
+            return lower;
+        } else {
+            greater.left = merge(lower, greater.left);
+            return greater;
+        }
+    }
+
+    public static NodePair splitBinary(Node orig, int value) {
+        if (orig == null)
+            return new NodePair(null, null);
+
+        if (orig.x < value) {
+            NodePair splitPair = splitBinary(orig.right, value);
+            orig.right = splitPair.first;
+            return new NodePair(orig, splitPair.second);
+        } else {
+            NodePair splitPair = splitBinary(orig.left, value);
+            orig.left = splitPair.second;
+            return new NodePair(splitPair.first, orig);
+        }
+    }
+
+    public static Node merge(Node lower, Node equal, Node greater) {
+        return merge(merge(lower, equal), greater);
+    }
+
+    public static SplitResult split(Node orig, int value) {
+        NodePair lowerOther = splitBinary(orig, value);
+        NodePair equalGreater = splitBinary(lowerOther.second, value + 1);
+        return new SplitResult(lowerOther.first, equalGreater.first, equalGreater.second);
+    }
+}
+
+    class Tree {
+        public boolean hasValue(int x) {
+            SplitResult splited = Node.split(mRoot, x);
+            boolean res = splited.equal != null;
+            mRoot = Node.merge(splited.lower, splited.equal, splited.greater);
+            return res;
+        }
+
+        public void insert(int x) {
+            SplitResult splited = Node.split(mRoot, x);
+            if (splited.equal == null)
+                splited.equal = new Node(x);
+            mRoot = Node.merge(splited.lower, splited.equal, splited.greater);
+        }
+
+        public void erase(int x) {
+            SplitResult splited = Node.split(mRoot, x);
+            mRoot = Node.merge(splited.lower, splited.greater);
+        }
+
+        private Node mRoot = null;
+    }
+
+class Main {
+    public static void main(String[] args) {
+        Tree tree = new Tree();
+        int cur = 5;
+        int res = 0;
+
+        for (int i = 1; i < 1000000; i++) {
+            int a = i % 3;
+            cur = (cur * 57 + 43) % 10007;
+            if (a == 0) {
+                tree.insert(cur);
+            } else if (a == 1) {
+                tree.erase(cur);
+            } else if (a == 2) {
+                boolean hasVal = tree.hasValue(cur);
+                if (hasVal)
+                    res++;
+            }
+        }
+        System.out.println(res);
+    }
+}

README.md

@@ -0,0 +1,119 @@
+| Language                         | Real Time, seconds | Slowdown Time | Memory, MB | Normalized Memory | Binary Size, MB                   |
+| -------------------------------- | ------------------ | ------------- | ---------- | ----------------- | --------------------------------- |
+| C++ "ref-counted" (clang / gcc)  | 0.55               | x2.5          | 0.5        | x1.3              | 0.023 + libstdc++                 |
+| C++ "raw-pointers" (clang / gcc) | 0.22               | x1            | 0.38       | x1                | 0.011 + libstdc++                 |
+| Rust "ref-counted"               | 0.66               | x3            | 0.5        | x1.3              | 0.479                             |
+| Rust "idiomatic"                 | 0.37               | x1.7          | 0.5        | x1.3              | 0.475                             |
+| JavaScript                       | 1.12               | x5            | 52         | x137              | N/A                               |
+| Java (no-limit / -Xm*50M)        | 0.50 / 0.50        | x2.3          | 142 / 29   | x374 / x76        | N/A                               |
+| Kotlin JVM (no-limit / -Xm*50M)  | 0.53 / 0.51        | x2.4          | 144 / 30   | x379 / x79        | N/A                               |
+| Kotlin Native                    | 5.88               | x26.7         | 1.2        | x3.2              | 0.239                             |
+| Swift                            | 2.04               | x9.3          | 2.5        | x6.6              | 0.020 + Swift shared libraries    |
+| Nim                              | 3.94               | x17.9         | 0.5        | x1.3              | 0.283                             |
+| Python (CPython 3.6)             | 12.25              | x55.7         | 5          | x13               | N/A                               |
+| Python (PyPy 6.0.0)              | 3.20               | x14.5         | 48.5       | x128              | N/A                               |
+
+# Compilation and Run
+
+## C++
+
+```
+clang++ -O3 -s -o main-clang main.cpp
+```
+
+```
+g++ -O3 -s -o main-gcc main.cpp
+```
+
+```
+./main-clang
+```
+
+## Rust
+
+```
+rustc +nightly -O -o main-rs main.rs
+strip -s main-rs
+```
+
+```
+./main-rs
+```
+
+## JavaScript
+
+```
+node main.js
+```
+
+## Java
+
+```
+javac -g:none Main.java
+```
+
+```
+java Main
+```
+
+```
+java -Xms50M -Xmx50M Main
+```
+
+## Kotlin JVM
+
+```
+kotlinc -include-runtime -d main-kt.jar ./main-jvm.kt
+```
+
+```
+java -jar main-kt.jar
+```
+
+```
+java -jar -Xms50M -Xmx50M main-kt.jar
+```
+
+## Kotlin Native
+
+```
+kotlinc-native -opt -o main-kt main.kt
+```
+
+```
+./main-kt.kexe
+```
+
+## Swift
+
+```
+swiftc -O -o main-swift main.swift
+strip -s main-swift
+```
+
+```
+./main-swift
+```
+
+## Nim
+
+```
+nim compile --opt:speed --out:main-nim main.nim
+strip -s main-nim
+```
+
+```
+./main-nim
+```
+
+## Python (CPython)
+
+```
+python main.py
+```
+
+## Python (PyPy)
+
+```
+pypy main.py
+```

main-idiomatic.rs

@@ -0,0 +1,123 @@
+#![feature(rustc_private)]
+extern crate rand;
+
+type NodeCell = Option<Box<Node>>;
+
+struct Node {
+    x: i32,
+    y: i32,
+    left: Option<Box<Node>>,
+    right: Option<Box<Node>>,
+}
+
+impl Node {
+    fn new(x: i32) -> Self {
+        Self {
+            x,
+            y: rand::random::<i32>(),
+            left: None,
+            right: None,
+        }
+    }
+}
+
+fn merge<'a>(lower: NodeCell, greater: NodeCell) -> NodeCell {
+    match (lower, greater) {
+        (None, greater) => greater,
+
+        (lower, None) => lower,
+
+        (Some(mut lower_node), Some(mut greater_node)) => {
+            if lower_node.y < greater_node.y {
+                lower_node.right = merge(lower_node.right.take(), Some(greater_node));
+                Some(lower_node)
+            } else {
+                greater_node.left = merge(Some(lower_node), greater_node.left.take());
+                Some(greater_node)
+            }
+        }
+    }
+}
+
+fn split_binary<'a>(orig: NodeCell, value: i32) -> (NodeCell, NodeCell) {
+    if let Some(mut orig_node) = orig {
+        if orig_node.x < value {
+            let split_pair = split_binary(orig_node.right.take(), value);
+            orig_node.right = split_pair.0;
+            (Some(orig_node), split_pair.1)
+        } else {
+            let split_pair = split_binary(orig_node.left.take(), value);
+            orig_node.left = split_pair.1;
+            (split_pair.0, Some(orig_node))
+        }
+    } else {
+        (None, None)
+    }
+}
+
+fn merge3(lower: NodeCell, equal: NodeCell, greater: NodeCell) -> NodeCell {
+    merge(merge(lower, equal), greater)
+}
+
+struct SplitResult {
+    lower: NodeCell,
+    equal: NodeCell,
+    greater: NodeCell,
+}
+
+fn split(orig: NodeCell, value: i32) -> SplitResult {
+    let (lower, equal_greater) = split_binary(orig, value);
+    let (equal, greater) = split_binary(equal_greater, value + 1);
+    SplitResult {
+        lower,
+        equal,
+        greater,
+    }
+}
+
+struct Tree {
+    root: NodeCell,
+}
+
+impl Tree {
+    pub fn new() -> Self {
+        Self { root: None }
+    }
+
+    pub fn has_value(&mut self, x: i32) -> bool {
+        let splited = split(self.root.take(), x);
+        let res = splited.equal.is_some();
+        self.root = merge3(splited.lower, splited.equal, splited.greater);
+        res
+    }
+
+    pub fn insert(&mut self, x: i32) {
+        let mut splited = split(self.root.take(), x);
+        if splited.equal.is_none() {
+            splited.equal = Some(Box::new(Node::new(x)));
+        }
+        self.root = merge3(splited.lower, splited.equal, splited.greater);
+    }
+
+    pub fn erase(&mut self, x: i32) {
+        let splited = split(self.root.take(), x);
+        self.root = merge(splited.lower, splited.greater);
+    }
+}
+
+fn main() {
+    let mut tree = Tree::new();
+    let mut cur = 5;
+    let mut res = 0;
+    for i in 1..1000000 {
+        let a = i % 3;
+        cur = (cur * 57 + 43) % 10007;
+        match a {
+            0 => tree.insert(cur),
+            1 => tree.erase(cur),
+            2 => res += if tree.has_value(cur) { 1 } else { 0 },
+            _ => {}
+        }
+    }
+    println!("{}", res);
+}