Merge pull request #1 from TheAlgorithms/master

Create CONTRIBUTING.md (TheAlgorithms#864)

Author: fengjixuchui

.gitignore

@@ -89,4 +89,5 @@ ENV/
 # Rope project settings
 .ropeproject
 .idea
-.DS_Store
+.DS_Store
+.try

.travis.yml

@@ -16,7 +16,7 @@ install:
     - pip install flake8  # pytest  # add another testing frameworks later
 before_script:
     # stop the build if there are Python syntax errors or undefined names
-    - flake8 . --count --select=E901,E999,F821,F822,F823 --show-source --statistics
+    - flake8 . --count --select=E9,F63,F72,F82 --show-source --statistics
     # exit-zero treats all errors as warnings.  The GitHub editor is 127 chars wide
     - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
 script:

CONTRIBUTING.md

@@ -0,0 +1,124 @@
+# Contributing guidelines
+
+## Before contributing
+
+Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Before sending your pull requests, make sure that you **read the whole guidelines**. If you have any doubt on the contributing guide, please feel free to [state it clearly in an issue](https://github.com/TheAlgorithms/Python/issues/new) or ask the community in [Gitter](https://gitter.im/TheAlgorithms).
+
+## Contributing
+
+### Contributor
+
+We are very happy that you consider implementing algorithms and data structure for others! This repository is referenced and used by learners from all over the globe. Being one of our contributors, you agree and confirm that:
+
+- your did your work - no plagiarism allowed
+  - Any plagiarized work will not be merged.
+- your work will be distributed under [MIT License](License) once your pull request is merged
+- you submitted work fulfils or mostly fulfils our styles and standards
+
+**New implementation** is welcome! For example, new solutions for a problem, different representations for a graph data structure or algorithm designs with different complexity.
+
+**Improving comments** and **writing proper tests** are also highly welcome.
+
+### Contribution
+
+We appreciate any contribution, from fixing a grammar mistake in a comment to implementing complex algorithms. Please read this section if you are contributing your work.
+
+#### Coding Style
+
+We want your work to be readable by others; therefore, we encourage you to note the following:
+
+- Please write in Python 3.x.
+
+- If you know [PEP 8](https://www.python.org/dev/peps/pep-0008/) already, you will have no problem in coding style, though we do not follow it strictly. Read the remaining section and have fun coding!
+
+- Always use 4 spaces to indent.
+
+- Original code submission requires comments to describe your work.
+
+- More on comments and docstrings:
+
+  The following are considered to be bad and may be requested to be improved:
+
+  ```python
+  x = x + 2	# increased by 2
+  ```
+
+  This is too trivial. Comments are expected to be explanatory. For comments, you can write them above, on or below a line of code, as long as you are consistent within the same piece of code.
+
+  *Sometimes, docstrings are avoided.* This will happen if you are using some editors and not careful with indentation:
+
+  ```python
+      """
+  	This function sums a and b    
+  """
+  def sum(a, b):
+      return a + b
+  ```
+
+  However, if you insist to use docstrings, we encourage you to put docstrings inside functions. Also, please pay attention to indentation to docstrings. The following is acceptable in this case:
+
+  ```python
+  def sumab(a, b):
+      """
+  	This function sums two integers a and b
+  	Return: a + b
+  	"""
+      return a + b
+  ```
+
+- `lambda`, `map`, `filter`, `reduce` and complicated list comprehension are welcome and acceptable to demonstrate the power of Python, as long as they are simple enough to read.
+
+  - This is arguable: **write comments** and assign appropriate variable names, so that the code is easy to read!
+
+- Write tests to illustrate your work.
+
+  The following "testing" approaches are not encouraged:
+
+  ```python
+  input('Enter your input:') 
+  # Or even worse...
+  input = eval(raw_input("Enter your input: "))
+  ```
+
+  Please write down your test case, like the following:
+
+  ```python
+  def sumab(a, b):
+      return a + b
+  # Write tests this way:
+  print(sumab(1,2))	# 1+2 = 3
+  print(sumab(6,4))	# 6+4 = 10
+  # Or this way:
+  print("1 + 2 = ", sumab(1,2))	# 1+2 = 3
+  print("6 + 4 = ", sumab(6,4))	# 6+4 = 10
+  ```
+
+- Avoid importing external libraries for basic algorithms. Use those libraries for complicated algorithms.
+
+#### Other Standard While Submitting Your Work
+
+- File extension for code should be `.py`.
+
+- Please file your work to let others use it in the future. Here are the examples that are acceptable:
+
+  - Camel cases
+  - `-` Hyphenated names
+  - `_` Underscore-separated names
+
+  If possible, follow the standard *within* the folder you are submitting to.
+
+- If you have modified/added code work, make sure the code compiles before submitting.
+
+- If you have modified/added documentation work, make sure your language is concise and contains no grammar mistake.
+
+- Add a corresponding explanation to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
+
+- Most importantly,
+
+  - **be consistent with this guidelines while submitting.**
+  - **join** [Gitter](https://gitter.im/TheAlgorithms) **now!**
+  - Happy coding!
+
+
+
+Writer [@poyea](https://github.com/poyea), Jun 2019.

Graphs/graph_list.py

@@ -0,0 +1,82 @@
+"""
+Prim's Algorithm.
+
+Determines the minimum spanning tree(MST) of a graph using the Prim's Algorithm
+
+Create a list to store x the vertices.
+G = [vertex(n) for n in range(x)]
+
+For each vertex in G, add the neighbors:
+G[x].addNeighbor(G[y])
+G[y].addNeighbor(G[x])
+
+For each vertex in G, add the edges:
+G[x].addEdge(G[y], w)
+G[y].addEdge(G[x], w)
+
+To solve run:
+MST = prim(G, G[0])
+"""
+
+import math
+
+
+class vertex():
+    """Class Vertex."""
+
+    def __init__(self, id):
+        """
+        Arguments:
+            id - input an id to identify the vertex
+
+        Attributes:
+            neighbors - a list of the vertices it is linked to
+            edges     - a dict to store the edges's weight
+        """
+        self.id = str(id)
+        self.key = None
+        self.pi = None
+        self.neighbors = []
+        self.edges = {}  # [vertex:distance]
+
+    def __lt__(self, other):
+        """Comparison rule to < operator."""
+        return (self.key < other.key)
+
+    def __repr__(self):
+        """Return the vertex id."""
+        return self.id
+
+    def addNeighbor(self, vertex):
+        """Add a pointer to a vertex at neighbor's list."""
+        self.neighbors.append(vertex)
+
+    def addEdge(self, vertex, weight):
+        """Destination vertex and weight."""
+        self.edges[vertex.id] = weight
+
+
+def prim(graph, root):
+    """
+    Prim's Algorithm.
+
+    Return a list with the edges of a Minimum Spanning Tree
+
+    prim(graph, graph[0])
+    """
+    A = []
+    for u in graph:
+        u.key = math.inf
+        u.pi = None
+    root.key = 0
+    Q = graph[:]
+    while Q:
+        u = min(Q)
+        Q.remove(u)
+        for v in u.neighbors:
+            if (v in Q) and (u.edges[v.id] < v.key):
+                v.pi = u
+                v.key = u.edges[v.id]
+    for i in range(1, len(graph)):
+        A.append([graph[i].id, graph[i].pi.id])
+    return(A)

Graphs/prim.py

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016 The Algorithms
+Copyright (c) 2019 The Algorithms
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

License renamed to LICENSE.md

@@ -0,0 +1,13 @@
+# Lucas Sequence Using Recursion
+
+def recur_luc(n):
+  if n == 1:
+    return n
+  if n == 0:
+    return 2
+  return (recur_luc(n-1) + recur_luc(n-2))
+    
+limit = int(input("How many terms to include in Lucas series:"))
+print("Lucas series:")
+for i in range(limit):
+  print(recur_luc(i))

Maths/lucasSeries.py

@@ -0,0 +1,8 @@
+a=3
+result=0
+while a=<1000:
+  if(a%3==0 and a%5==0):
+    result+=a
+  elif(a%15==0):
+    result-=a
+print(result)