victory 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 338b333cefdfe98444e20851393081ad3af713717bf00f346d99826732721280
-  data.tar.gz: cc5c8517bc3ba2ff7d8b662f72901d47673c32921d62fa4e65d19afd294c110f
+  metadata.gz: 717f4606348a07fae563b347197930dc0ebae3a48f1d28fc83edf3f6616197c7
+  data.tar.gz: 968a58a7f01bd4659ba396b570db14821eeafb318294b5a9deb3c8ba8dc02647
 SHA512:
-  metadata.gz: ff55c99e4e2b5974e6b373ed6dfecd1b7134623b9a13107d9a8f7871e63fac3350d407f2c07e7b6b6bbdd9f89f21af8e88799101d8fd874f03859460ad8c638c
-  data.tar.gz: 210bd6551491e26c9b4f41b217fea8cef55521edb11a99fa5703b3e392d778daf835085e2c1d0b17d26739ddd0c6aa87faecb6a62257fab2a633fea80c252fcf
+  metadata.gz: fe1daf498c13876f2a8d580cb5c2d1fcf22581dabb88858d56925d034380cddadf060c78ac07b80fd302538177ad79543466b951699bee92e1722dac3f60e7ed
+  data.tar.gz: 77305c8712aa38e77ca69e9fa907bd5cc00a905bd4b9e1966a8a958e927b7bde1b6179e7890743d370707aeabce2a3a0cfaf9d6e78363dc613fa10e9a6ec8091

data/.gitignore

@@ -96,3 +96,8 @@ fabric.properties
 .idea/sonarlint
 
 # End of https://www.gitignore.io/api/intellij
+
+.idea/
+
+Gemfile.lock
+**/*.gem

data/.rubocop.yml

@@ -13,4 +13,14 @@ Layout/SpaceAroundOperators:
 Style/TrailingCommaInArrayLiteral:
   Enabled: false
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.6
+Style/WordArray:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/MethodLength:
+  Max: 20
+Style/Documentation:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/README.md

@@ -1,8 +1,6 @@
 # Victory
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/victory`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+A gem providing all useful algorithms and data structures for contests
 
 ## Installation
 
@@ -22,7 +20,7 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Can be found at [usage](https://github.com/Szetty/victory/blob/master/USAGE.md).
 
 ## Development
 
@@ -32,7 +30,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/victory. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/Szetty/victory. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -40,4 +38,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Victory project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/victory/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Victory project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Szetty/victory/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -11,8 +11,15 @@ require "rake/extensiontask"
 
 task :build => :compile
 
-Rake::ExtensionTask.new("victory") do |ext|
-  ext.lib_dir = "lib/victory"
-end
+Rake::ExtensionTask.new('algorithms/string')        { |ext| ext.name = "CString" }
+Rake::ExtensionTask.new('containers/deque')         { |ext| ext.name = "CDeque" }
+Rake::ExtensionTask.new('containers/bst')           { |ext| ext.name = "CBst" }
+Rake::ExtensionTask.new('containers/rbtree_map')    { |ext| ext.name = "CRBTreeMap" }
+Rake::ExtensionTask.new('containers/splaytree_map') { |ext| ext.name = "CSplayTreeMap" }
+Rake::ExtensionTask.new('containers/xor_list') { |ext| ext.name = 'XORList' }
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
 
-task :default => [:clobber, :compile, :test]
+task :default => [:clobber, :compile, :spec, :test]

data/USAGE.md

@@ -0,0 +1,159 @@
+# Usage
+
+In this markdown you will see the usage of all the datastructures and algorithms available through the standard library and this gem.
+
+# Data Structures
+
+* [Array](#array)
+* [Hash](#hash)
+* [Set](#set)
+* [Struct](#struct)
+* [OpenStruct](#openstruct)
+* [Tuple](#tuple)
+
+<a name="array" />
+
+## Array
+
+```ruby
+[]
+# => []
+Array.new(4)
+# => [nil, nil, nil, nil]
+Array.new(4, 4)
+# => [4, 4, 4, 4]
+  
+a = [:a, :b, :c, :d]
+a[2]
+# => :c
+a[1] = 3
+a
+# => [:a, 3, :c, :d]
+
+b = [1,2,3]
+b[10] = :foo
+b
+# => [1, 2, 3, nil, nil, nil, nil, nil, nil, nil, :foo]
+```
+
+<a name="hash" />
+
+## Hash 
+
+```ruby
+{}
+Hash.new(default = nil)
+# => {}
+{"a" => 100, "b" => 200}
+# => {"a"=>100, "b"=>200}
+{a: 100, b: 200}
+# => {:a=>100, :b=>200}
+a = {}
+a[1] = 2
+a
+# => {1=>2}
+a[1]
+# => 2 
+```
+
+<a name="set" />
+
+## Set 
+
+```ruby
+require 'set'
+
+s = Set.new
+# => #<Set: {}> 
+s << :a
+# => #<Set: {:a}> 
+s << :a
+# => #<Set: {:a}> 
+s << :b
+# => #<Set: {:a, :b}> 
+```
+
+<a name="struct" />
+
+## Struct
+
+```ruby
+Face = Struct.new(:hair, :eyes, :skin)
+
+my_face = Face.new :blond, :blue, :awesome
+# => #<struct Face hair=:blond, eyes=:blue, skin=:awesome>
+
+my_face[:hair]
+# => :blond 
+my_face.hair
+# => :blond 
+my_face.nose
+# NoMethodError: undefined method `nose' for #<struct Face hair=:blond, eyes=:blue, skin=:awesome>
+my_face[:nose]
+# NameError: no member 'nose' in struc
+ 
+
+class PayChecks < Struct.new(:week1, :week2, :week3, :week4)
+  def total
+    inject :+
+  end
+end
+
+pay_checks = PayChecks.new 100, 800, 300, 45
+# => #<struct PayChecks week1=100, week2=800, week3=300, week4=45> 
+pay_checks.total
+# => 1245 
+```
+
+<a name="openstruct" />
+
+## OpenStruct
+
+```ruby
+require 'ostruct'
+
+x = OpenStruct.new
+# => #<OpenStruct> 
+
+x[:a]
+# => nil 
+x
+# => #<OpenStruct> 
+
+x[:a] = 0
+# => 0 
+x
+# => #<OpenStruct a=0> 
+x.a
+# => 0 
+
+x.b
+# => nil 
+x
+# => #<OpenStruct a=0> 
+x[:b]  = 123
+# => 123 
+x
+# => #<OpenStruct a=0, b=123>
+```
+
+<a name="tuple" />
+
+## Tuple
+
+```ruby
+t = T[1, 2, 3]
+
+a, _, c = *t
+a
+# => 1
+c
+# => 3
+t[2]
+# => 2
+```
+
+# Other useful links
+
+* https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/
+* https://github.com/sagivo/algorithms

data/ext/algorithms/string/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2009 Kanwei Li 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/ext/algorithms/string/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = "CString"
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/algorithms/string/string.c

@@ -0,0 +1,68 @@
+#include "ruby.h"
+
+long min_three(long a, long b, long c) {
+	long min = a;
+	if (b < min)
+		min = b;
+	if( c < min)
+		min = c;
+	return min;
+}
+
+long levenshtein_distance(VALUE str1, VALUE str2) {
+	long i, j, s1_len, s2_len, *d;
+	char * s = RSTRING_PTR(str1);
+	char * t = RSTRING_PTR(str2);
+	s1_len = RSTRING_LEN(str1);
+	s2_len = RSTRING_LEN(str2);
+	
+	if (s1_len == 0) {
+		return s2_len;
+	} else if (s2_len == 0) {
+		return s1_len;
+	}
+	
+	// We need one extra col and row for the matrix for starting values
+	s1_len++;
+	s2_len++;
+	
+	d = xmalloc(sizeof(typeof(d)) * s1_len * s2_len);
+	
+	for (i = 0; i < s1_len; i++) {
+		d[i] = i; // d[i, 0] = i
+	}
+	for (j = 0; j < s2_len; j++) {
+		d[j*s1_len] = j; // d[0, j] = j
+	}
+	
+	for (i = 1; i < s1_len; i++) {
+		for (j = 1; j < s2_len; j++) {
+			if (s[i-1] == t[j-1]) {
+				d[j * s1_len + i] = d[(j-1) * s1_len + (i-1)];
+			} else {
+				d[j * s1_len + i] = 1 + min_three(
+					d[j * s1_len + (i-1)],
+					d[(j-1) * s1_len + i],
+					d[(j-1) * s1_len + (i-1)]
+				);
+			}
+		}
+	}
+	i = d[s1_len * s2_len -1];
+	xfree(d);
+	return i;
+}
+
+static VALUE lev_dist(VALUE self, VALUE str1, VALUE str2) {
+	return LONG2FIX(levenshtein_distance( str1, str2 ));
+}
+
+static VALUE mAlgorithms;
+static VALUE mString;
+
+void Init_CString() {	
+	mAlgorithms = rb_define_module("Algorithms");
+	mString = rb_define_module_under(mAlgorithms, "String");
+	rb_define_singleton_method(mString, "levenshtein_dist", lev_dist, 2);
+}
+

data/ext/containers/bst/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2009 Kanwei Li 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/ext/containers/bst/bst.c

@@ -0,0 +1,247 @@
+#include "ruby.h"
+
+typedef struct struct_bst_node {
+	VALUE key;
+	VALUE value;
+	struct struct_bst_node *left;
+	struct struct_bst_node *right;
+	struct struct_bst_node *parent;
+} bst_node;
+
+typedef struct struct_bst {
+	bst_node *root;
+	int (*compare_function)(VALUE key1, VALUE key2);
+	unsigned int size; 
+} bst;
+
+static VALUE bst_initialize(VALUE self) {
+	return self;
+}
+
+static bst* get_bst_from_self(VALUE self) {
+	bst *tree;
+	Data_Get_Struct(self, bst, tree);
+	return tree;
+}
+
+static bst* bst_each_node(bst *tree, bst_node *node, void (*each)(bst *tree_, bst_node *node_, void* args), void* arguments) {
+	if (!node)
+		return NULL;
+	
+		if (node->left)
+			bst_each_node(tree, node->left, each, arguments);
+		
+		(*each)(tree, node, arguments);
+		
+		if (node->right)
+			bst_each_node(tree, node->right, each, arguments);
+	return tree;
+}
+
+static bst* bst_each(bst *tree, void (*each)(bst *tree, bst_node *node, void *args), void* arguments) {
+	if (tree->root)
+		bst_each_node(tree, tree->root, each, arguments);
+	return tree;
+}
+
+static VALUE id_compare_operator;
+
+static int bst_compare_function(VALUE a, VALUE b) {
+	if (a == b) return 0;
+	if (FIXNUM_P(a) && FIXNUM_P(b)) {
+		long x = FIX2LONG(a), y = FIX2LONG(b);
+		if (x == y) return 0;
+		if (x > y) return 1;
+		return -1;
+	}
+	if (TYPE(a) == T_STRING && rb_obj_is_kind_of(a, rb_cString) &&
+            TYPE(b) == T_STRING && rb_obj_is_kind_of(b, rb_cString)) {
+		return rb_str_cmp(a, b);
+	}
+	return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
+}
+
+static void insert_element(bst *tree, bst_node **t,bst_node *newElement) {
+	int cmp;
+	bst_node *y = NULL;
+	bst_node *x = *t;
+	while (x != NULL) {
+		y = x;
+		cmp = tree->compare_function(newElement->key, x->key);
+		if (cmp < 0) x = x->left;
+		else x = x->right;
+	}
+	newElement->parent = y;
+	if (y == NULL) *t = newElement;
+	else {
+		cmp = tree->compare_function(newElement->key, y->key);
+		if (cmp < 0)
+		 	y->left = newElement;
+		else 
+			y->right = newElement;
+	}
+}
+
+
+static bst_node* create_node(VALUE key_value,VALUE value) {
+	bst_node *new_node = ALLOC(bst_node);
+	new_node->value = value;
+	new_node->key = key_value;
+	new_node->left = NULL;
+	new_node->right = NULL;
+	new_node->parent = NULL;
+	return new_node;	 
+}
+
+static bst_node* tree_minimum (bst_node *tree) {
+	bst_node *x = tree;
+	while (x->left) x = x->left;
+	return x;
+}
+
+static bst_node* tree_maximum (bst_node *tree) {
+	bst_node *x = tree;
+	while (x->right) x = x->right;
+	return x;
+}
+
+static bst_node* node_successor (bst_node *tree,bst_node *x) {
+	if (x->right) return tree_minimum(x->right);
+	bst_node *y = x->parent;
+	while (y && x == y->right) {
+		x = y;
+		y = x->parent;
+	}
+	return y;
+}
+
+
+static bst_node* delete_node (bst_node **tree,bst_node *tobeDeleted) {
+	bst_node *y,*x;
+
+	if ((tobeDeleted->left == NULL) || (tobeDeleted->right == NULL)) y = tobeDeleted;
+	else y = node_successor(*tree,tobeDeleted);
+
+	if (y->left) x = y->left;
+	else x = y->right;
+
+	if (x) x->parent = y->parent;
+
+	if (y->parent == NULL) {
+		*tree = x;
+		return y;
+	} else if (y == y->parent->left) {
+		y->parent->left = x;
+	} else {
+		y->parent->right = x;
+	}
+
+	if (tobeDeleted != y) tobeDeleted->key = y->key;
+	return y;
+}
+
+static bst_node* search_node(bst *tree, bst_node *node, VALUE key) {
+	bst_node *x = node;
+	int cmp;
+	
+	while(x) {
+		cmp = tree->compare_function(key, x->key);
+		if (cmp == 0) return x;
+		else if (cmp < 0) { x = x->left; }
+		else { x = x->right; }
+	}
+	return NULL;
+}
+
+static void recursively_mark_nodes(bst_node *node) {
+	if(node) {
+		rb_gc_mark(node->key);
+		rb_gc_mark(node->value);
+		recursively_mark_nodes(node->left);
+		recursively_mark_nodes(node->right);
+	}
+}
+
+static void bst_mark(bst *tree) {
+	if (tree) {
+		recursively_mark_nodes(tree->root);
+	}
+}
+
+static void recursively_free_nodes(bst_node *node) {
+	if(node) {
+		recursively_free_nodes(node->left);
+		recursively_free_nodes(node->right);
+		xfree(node);
+	}
+}
+
+static void bst_free(bst *tree) {
+	if (tree) {
+		recursively_free_nodes(tree->root);
+	}
+}
+
+static bst* create_bst(int (*compare_function)(VALUE, VALUE)) {
+	bst *tree = ALLOC(bst);
+	tree->compare_function = compare_function;
+	tree->root = NULL;
+	tree->size = 0;
+	return tree;
+}
+
+static VALUE bst_alloc(VALUE klass) {
+	bst *tree = create_bst(&bst_compare_function);
+	return Data_Wrap_Struct(klass, bst_mark, bst_free, tree);
+}
+
+static VALUE rb_bst_push_value(VALUE self, VALUE key, VALUE value) {
+	bst *tree = get_bst_from_self(self);
+	insert_element(tree, &(tree->root), create_node(key,value));
+	tree->size++;
+	return self;
+}
+
+static void bst_each_helper(bst *tree, bst_node *node, void *args) {
+	rb_yield(rb_ary_new3(2, node->key, node->value));
+};
+
+static VALUE rb_bst_each(VALUE self) {
+	bst *tree = get_bst_from_self(self);
+	bst_each(tree, &bst_each_helper, NULL);
+	return self;
+}
+
+static VALUE rb_bst_delete(VALUE self, VALUE key) {
+	bst *tree = get_bst_from_self(self);
+	bst_node *tobeDeleted = search_node(tree, tree->root, key);
+	if(tobeDeleted) { 
+		tree->size -= 1;
+		bst_node *deletedNode = delete_node(&(tree->root),tobeDeleted);
+		return deletedNode->value;
+	}
+	return Qnil;
+}
+
+static VALUE rb_bst_size(VALUE self) { 
+	bst *tree;
+	Data_Get_Struct(self,bst,tree);
+	return INT2FIX(tree->size);
+}
+
+static VALUE CBst;
+static VALUE mContainers;
+
+void Init_CBst() {
+	id_compare_operator = rb_intern("<=>");
+
+	mContainers = rb_define_module("Containers");
+	CBst = rb_define_class_under(mContainers, "CBst", rb_cObject);
+	rb_define_alloc_func(CBst, bst_alloc);
+	rb_define_method(CBst, "initialize", bst_initialize, 0);
+	rb_define_method(CBst, "push", rb_bst_push_value, 2);
+	rb_define_alias(CBst, "[]=", "push");
+	rb_define_method(CBst, "each", rb_bst_each, 0);
+	rb_define_method(CBst, "delete", rb_bst_delete, 1);
+	rb_define_method(CBst, "size", rb_bst_size, 0);
+}

data/ext/containers/bst/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = "CBst"
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/containers/deque/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2009 Kanwei Li 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.