Merge branch 'master' into master

CONTRIBUTORS.md

@@ -1,10 +1,21 @@
+Name: [Rocarft](https://github.com/rocarft)<br/>
+Place: Georgia<br/>
+About: Music, Coding, Fun!<br/>
+Programming Language: Html, CSS, JS, C++, C#, Python<br/>
+Email: [email protected]<br/>
 
 Name: [Ryssmo](https://github.com/Ryssmo)<br/>
 Place: Norway<br/>
 About: Coding is life<br/>
 Programming Language: Html, CSS, JS<br/>
 Email: [email protected]<br/>
 
+Name: [Md Inzamamul Haque](https://github.com/mihaque313)
+Place: Patna
+About: I love to code, solve programming problems. Currently workingas devOps engineer at Relevance lab, Bangalore.
+Programming Language: C, python, java, ruby, scala, JS, bash 
+Email: [email protected]
+
 
 Name: [Miftahul J.](https://github.com/jiadibo)<br/>
 Place: Indonesia<br/>
@@ -815,8 +826,41 @@ About: I am studying System development.<br/>
 Programming Language:PHP, Java, Pascal<br/>
 
 
+
 Name: [Jiradeto](https://github.com/jiradeto)<br/>
 Place: Bolzano, Italy<br/>
 About: master student who enjoy coding.<br/>
 Programming Language:Ruby, Java, JavaScript<br/>
 
+Name: [Vilmos Hegyi](https://github.com/foxxydev)
+Place: Arad, Romania
+About: Computer Science student in his third year of studies, also full time Software Developer.
+Programming Language: C++, C#, Java, HTML/HTML5, CSS/CSS3, JavaScript, mySQL, PHP
+Email: [email protected]
+
+Name: [Salif Moin](https://github.com/salif-04)<br/>
+Place: Jamshedpur<br/>
+About: I am a Computer Science and Engineering student.<br/>
+Programming Language: Java, Python, C, C++, JavaScript<br/>
+Email: [email protected]
+
+
+
+Name: [Priyadarshan Singh](https://github.com/PDROJACK)
+Place: Delhi
+About: CS undergraduate
+Programming Language: Python,Javascript,C,C++
+Email: [email protected]
+
+Name: [emekoi](https://github.com/emekoi)
+Place: antarctica
+About: i like programming but i can't finish anything
+Programming Language: c, zig, lua, nim, rust (kinda), java (kinda)
+
+
+
+Name: [Pijus](https://github.com/pijusrancevas)
+Place: Horsens, Denmark
+About: Software Engineer student
+Programming Language: Python, Javascript, JAVA (soon), C# 
+

Circular linkedlist/DSN_CircularLinkedLIst.c

@@ -0,0 +1,64 @@
+#include<stdlib.h>
+#include<stdio.h>
+
+struct circularNode{
+    int data;
+    struct circularNode* next;
+};
+
+struct circularNode* createnode(int a){
+    struct circularNode* newnode = (struct circularNode*)malloc(sizeof(struct circularNode));
+
+    newnode->data=a;
+    newnode->next=NULL;
+
+    return newnode;
+};
+
+void show(struct circularNode* head){
+    struct circularNode* temp=head;
+    if(head==NULL){
+        return;
+    }
+    do{
+        printf("%d ",temp->data);
+        temp=temp->next;
+    }while(temp!=head);
+}
+
+void insert_front(struct circularNode** head,int a){
+    struct circularNode *p = *head;
+    struct circularNode* newnode = (struct circularNode*)malloc(sizeof(struct circularNode));
+    newnode->data = a;
+
+    if(*head==NULL){
+        *head=newnode;
+        newnode->next=NULL;
+    }
+
+    newnode->next=p->next;
+    (*head)=newnode;
+
+}
+
+void insert_end(struct circularNode** head,int a){
+    struct circularNode *p;
+    struct circularNode * newnode = (struct circularNode*)malloc(sizeof(struct circularNode));
+    p=*head;
+    newnode->data=a;
+    while(p!=*head){
+        p=p->next;
+    }
+    if(*head==NULL){
+        *head=newnode;
+    }
+    newnode->next=*head;
+    p->next=newnode;
+}
+
+
+int main(){
+    struct circularNode* a = createnode(7);
+    insert_front(&a, 5);
+    show(a);
+}

Decision_Tree.py

@@ -0,0 +1,138 @@
+"""
+Implementation of a basic regression decision tree.
+Input data set: The input data set must be 1-dimensional with continuous labels.
+Output: The decision tree maps a real number input to a real number output. 
+"""
+
+import numpy as np
+
+class Decision_Tree:
+    def __init__(self, depth = 5, min_leaf_size = 5):
+        self.depth = depth
+        self.decision_boundary = 0
+        self.left = None
+        self.right = None
+        self.min_leaf_size = min_leaf_size
+        self.prediction = None
+
+    def mean_squared_error(self, labels, prediction):
+        """
+        mean_squared_error:
+        @param labels: a one dimensional numpy array 
+        @param prediction: a floating point value
+        return value: mean_squared_error calculates the error if prediction is used to estimate the labels
+        """
+        if labels.ndim != 1:
+            print("Error: Input labels must be one dimensional")
+
+        return np.mean((labels - prediction) ** 2)
+
+    def train(self, X, y):
+        """
+        train:
+        @param X: a one dimensional numpy array
+        @param y: a one dimensional numpy array. 
+        The contents of y are the labels for the corresponding X values
+        train does not have a return value
+        """
+
+        """
+        this section is to check that the inputs conform to our dimensionality constraints
+        """
+        if X.ndim != 1:
+            print("Error: Input data set must be one dimensional")
+            return
+        if len(X) != len(y):
+            print("Error: X and y have different lengths")
+            return
+        if y.ndim != 1:
+            print("Error: Data set labels must be one dimensional")
+            return
+
+        if len(X) < 2 * self.min_leaf_size:
+            self.prediction = np.mean(y)
+            return
+
+        if self.depth == 1:
+            self.prediction = np.mean(y)
+            return
+
+        best_split = 0
+        min_error = self.mean_squared_error(X,np.mean(y)) * 2
+
+
+        """
+        loop over all possible splits for the decision tree. find the best split.
+        if no split exists that is less than 2 * error for the entire array
+        then the data set is not split and the average for the entire array is used as the predictor
+        """
+        for i in range(len(X)):
+            if len(X[:i]) < self.min_leaf_size:
+                continue
+            elif len(X[i:]) < self.min_leaf_size:
+                continue
+            else:
+                error_left = self.mean_squared_error(X[:i], np.mean(y[:i]))
+                error_right = self.mean_squared_error(X[i:], np.mean(y[i:]))
+                error = error_left + error_right
+                if error < min_error:
+                    best_split = i
+                    min_error = error
+
+        if best_split != 0:
+            left_X = X[:best_split]
+            left_y = y[:best_split]
+            right_X = X[best_split:]
+            right_y = y[best_split:]
+
+            self.decision_boundary = X[best_split]
+            self.left = Decision_Tree(depth = self.depth - 1, min_leaf_size = self.min_leaf_size)
+            self.right = Decision_Tree(depth = self.depth - 1, min_leaf_size = self.min_leaf_size)
+            self.left.train(left_X, left_y)
+            self.right.train(right_X, right_y)
+        else:
+            self.prediction = np.mean(y)
+
+        return
+
+    def predict(self, x):
+        """
+        predict:
+        @param x: a floating point value to predict the label of
+        the prediction function works by recursively calling the predict function
+        of the appropriate subtrees based on the tree's decision boundary
+        """
+        if self.prediction is not None:
+            return self.prediction
+        elif self.left or self.right is not None:
+            if x >= self.decision_boundary:
+                return self.right.predict(x)
+            else:
+                return self.left.predict(x)
+        else:
+            print("Error: Decision tree not yet trained")
+            return None
+
+def main():
+    """
+    In this demonstration we're generating a sample data set from the sin function in numpy.
+    We then train a decision tree on the data set and use the decision tree to predict the
+    label of 10 different test values. Then the mean squared error over this test is displayed.
+    """
+    X = np.arange(-1., 1., 0.005)
+    y = np.sin(X)
+
+    tree = Decision_Tree(depth = 10, min_leaf_size = 10)
+    tree.train(X,y)
+
+    test_cases = (np.random.rand(10) * 2) - 1
+    predictions = np.array([tree.predict(x) for x in test_cases])
+    avg_error = np.mean((predictions - test_cases) ** 2)
+
+    print("Test values: " + str(test_cases))
+    print("Predictions: " + str(predictions))
+    print("Average error: " + str(avg_error))
+
+
+if __name__ == '__main__':
+    main()

LICENSE

@@ -1,5 +1,5 @@
                     GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+                       Version 3, 29 June 2018
 
  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
@@ -671,4 +671,4 @@ into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+<http://www.gnu.org/philosophy/why-not-lgpl.html>

Roman Conversion In Python/Roman.py

@@ -0,0 +1,58 @@
+# Python program to convert Roman Numerals 
+# to Numbers 
+
+# This function returns value of each Roman symbol 
+def value(r): 
+    if (r == 'I'): 
+        return 1
+    if (r == 'V'): 
+        return 5
+    if (r == 'X'): 
+        return 10
+    if (r == 'L'): 
+        return 50
+    if (r == 'C'): 
+        return 100
+    if (r == 'D'): 
+        return 500
+    if (r == 'M'): 
+        return 1000
+    return -1
+
+def romanToDecimal(str): 
+    res = 0
+    i = 0
+
+    while (i < len(str)): 
+
+        # Getting value of symbol s[i] 
+        s1 = value(str[i]) 
+
+        if (i+1 < len(str)): 
+
+            # Getting value of symbol s[i+1] 
+            s2 = value(str[i+1]) 
+
+            # Comparing both values 
+            if (s1 >= s2): 
+
+                # Value of current symbol is greater 
+                # or equal to the next symbol 
+                res = res + s1 
+                i = i + 1
+            else: 
+
+                # Value of current symbol is greater 
+                # or equal to the next symbol 
+                res = res + s2 - s1 
+                i = i + 2
+        else: 
+            res = res + s1 
+            i = i + 1
+
+    return res 
+
+# Driver code
+a=input("Enter Roman Number:")
+print("Integer form of Roman Numeral is"), 
+print(romanToDecimal(a))