Quicksort.py file is updated

CONTRIBUTION GUIDELINES.md

@@ -0,0 +1,103 @@
+# CONTRIBUTION GUIDE:
+
+WIEWoC encourages individuals to share their knowledge and ideas to develop technical skills and gain valuable experience in the field of technology. We are creating a PYTHON content repository which is full of valuable resources. Folders for different domains like Web Development, GUI, ML with Python have been created and contribution to a specific domain will go to that folder only. Inside each directory there will be subdirectories for sub-topics of that particular domain. There is a specific branch for each of the domains and participants need to contribute to that branch only. For example, if someone is contributing to Web Development or a subtopic of it, contributions to that domain should only go to that branch.
+
+## Types of contribution you can make
+Any contribution you make, code is necessary.
+1. Documentation + Code
+2. Code only
+3. Code + Self made Video/Audio (uploaded in youtube or gdrive)
+
+## Adding new subtopics under domains
+Create a folder with name of the sub topic, add your content and create PR in respective domain branch.
+For example you want to add subtopic JPython in GUI. Create a folder named JPython and upload in GUI Folder and create PR from gui branch.
+
+## Basics of Git and GitHub
+
+### Git & GitHub
+
+Before we proceed, it's better to know the difference between Git and Github. Git is a version control system (VCS) that allows us to keep track of the history of our source code , whereas GitHub is a service that hosts Git projects. 
+
+We assume you have created an account on Github and installed Git on your System.
+
+Now enter your name and E-mail (used on Github) address in Git, by using following command.
+
+`$ git config --global user.name "YOUR NAME"`
+` $ git config --global user.email "YOUR EMAIL ADDRESS"`
+This is an important step to mark your commits to your name and email.
+
+<br />
+
+### Fork a project
+
+You can make a copy of the project to your account. This process is called forking a project to your Github account. On Upper right side of project page on Github, you can see -
+
+<p align="center">  <img  src="https://i.imgur.com/P0n6f97.png">  </p>
+Click on fork to create a copy of project to your account. This creates a separate copy for you to work on.
+
+<br />
+
+<br />
+
+### Clone the forked project
+
+You have forked the project you want to contribute to your github account. To get this project on your development machine we use clone command of git.
+
+`$ git clone https://github.com/IEEE-WIE-VIT/WIE-WoC.git` <br/>
+Now you have the project on your local machine.
+
+<br />
+
+### Add a remote (upstream) to original project repository
+
+Remote means the remote location of project on Github. By cloning, we have a remote called origin which points to your forked repository. Now we will add a remote to the original repository from where we had forked.
+
+`$ cd <your-forked-project-folder>`
+`$ git remote add upstream https://github.com/IEEE-WIE-VIT/WIE-WoC.git` <br/>
+You will see the benefits of adding remote later.
+
+<br />
+
+### Synchronizing your fork
+
+Open Source projects have a number of contributors who can push code anytime. So it is necessary to make your forked copy equal with the original repository. The remote added above called Upstream helps in this.
+
+`$ git checkout main`
+`$ git fetch upstream`
+`$ git merge upstream/main`
+`$ git push origin main` <br/>
+The last command pushes the latest code to your forked repository on Github. The origin is the remote pointing to your forked repository on github.
+
+<br />
+
+### Create a new branch for a feature or bugfix
+
+Usually, all repositories have a main branch that is regarded to be stable, and any new features should be developed on a separate branch before being merged into the main branch. As a result, we should establish a new branch for our feature or bugfix and go to work on the issue. 
+
+`$ git checkout -b <feature-branch>`
+This will create a new branch out of master branch. Now start working on the problem and commit your changes.
+
+`$ git add --all`
+`$ git commit -m "<commit message>"`
+The first command adds all the files or you can add specific files by removing -a and adding the file names. The second command gives a message to your changes so you can know in future what changes this commit makes. If you are solving an issue on original repository, you should add the issue number like #35 to your commit message. This will show the reference to commits in the issue.
+
+<br />
+
+### Push code and create a pull request
+
+You now have a new branch containing the modifications you want in the project you forked. Now, push your new branch to your remote github fork. 
+
+`$ git push origin <feature-branch>`
+Now you are ready to help the project by opening a pull request means you now tell the project managers to add the feature or bug fix to original repository. You can open a pull request by clicking on green icon -
+
+<p align="center">  <img  src="https://i.imgur.com/aGaqAD5.png">  </p>
+
+Remember your upstream base branch should be main and source should be your feature branch. Click on create pull request and add a name to your pull request. You can also describe your feature.
+
+Amazing! You've already made your first contribution.🥳
+
+#### BE OPEN FOR US TO CONTACT YOU!
+
+#### Happy Coding 👩‍💻👩‍💻
+
+

DSA Coding/Array/BinarySearch.py

@@ -0,0 +1,19 @@
+# Binary Search
+
+def binary_search(arr, target):
+    low = 0
+    high = len(arr) - 1
+    while low <= high:
+        mid = (low + high) // 2
+        if arr[mid] == target:
+            return mid
+        elif arr[mid] < target:
+            low = mid + 1
+        else:
+            high = mid - 1
+    return -1
+
+n = int(input("Enter number: "))
+arr = list(map(int, input().split()))
+target = int(input("Enter target: "))
+print(binary_search(arr, target))

DSA Coding/Array/BubbleSort.py

@@ -0,0 +1,12 @@
+#Bubble Sort 
+
+def bubbleSort(arr):
+    for i in range(len(arr)):
+        for j in range(len(arr)-1-i):
+            if arr[j] > arr[j+1]:
+                arr[j], arr[j+1] = arr[j+1], arr[j]
+    return arr
+
+n = int(input("Enter number: "))
+arr = list(map(int, input().split()))
+print(bubbleSort(arr))

DSA Coding/Array/Consecutive_Prime_Sum.py

@@ -0,0 +1,40 @@
+def isPrime(num):
+        i=2
+        flag=0
+        while(i*i <= num):
+            if(num%i==0):
+                flag+=1
+                break
+            i+=1
+        if(flag==1):
+            return 0
+        else:
+            return 1
+
+t = int(input())
+
+for i in range(t):
+    n = int(input())
+    l = []
+    for k in range(2,n+1):
+        if isPrime(k):
+            l.append(k)
+    count = 0
+    sumt = 0
+    nl = l[2:]
+    for i in range(0,len(l)):
+        sumt += l[i]
+        if sumt in nl:
+            count += 1
+    print(count)
+
+
+
+
+
+
+
+
+
+
+

DSA Coding/Array/CountingSort.py

@@ -0,0 +1,19 @@
+# Counting Sort
+
+def countingSort(arr):
+    max_val = max(arr)
+    min_val = min(arr)
+    count = [0] * (max_val - min_val + 1)
+    for i in arr:
+        count[i - min_val] += 1
+    index = 0
+    for i in range(len(count)):
+        while count[i] > 0:
+            arr[index] = i + min_val
+            index += 1
+            count[i] -= 1
+    return arr
+
+n = int(input("Enter number: "))
+arr = list(map(int, input().split()))
+print(*countingSort(arr))

DSA Coding/Array/HeapSort.py

@@ -0,0 +1,26 @@
+#Heap Sort
+
+def heapify(arr, n, i):
+    largest = i
+    l = 2 * i + 1
+    r = 2 * i + 2
+    if l < n and arr[i] < arr[l]:
+        largest = l
+    if r < n and arr[largest] < arr[r]:
+        largest = r
+    if largest != i:
+        arr[i], arr[largest] = arr[largest], arr[i]
+        heapify(arr, n, largest)
+
+def heapSort(arr):
+    n = len(arr)
+    for i in range(n, -1, -1):
+        heapify(arr, n, i)
+    for i in range(n-1, 0, -1):
+        arr[i], arr[0] = arr[0], arr[i]
+        heapify(arr, i, 0)
+    return arr
+
+n = int(input("Enter number: "))
+arr = list(map(int, input().split()))
+print(*heapSort(arr))

DSA Coding/Array/InsertionSort.py

@@ -0,0 +1,15 @@
+def insertion_sort(alist):
+    for i in range(1, len(alist)):
+        temp = alist[i]
+        j = i - 1
+        while (j >= 0 and temp < alist[j]):
+            alist[j + 1] = alist[j]
+            j = j - 1
+        alist[j + 1] = temp
+
+
+alist = input('Enter the list of numbers: ').split()
+alist = [int(x) for x in alist]
+insertion_sort(alist)
+print('Sorted list: ', end='')
+print(alist)

DSA Coding/Array/KadaneAlgo.py

@@ -0,0 +1,15 @@
+def kadaneAlgorithm(n,arr):
+    sum_num = 0
+    max_sum = 0
+    for i in range(n):
+        sum_num += arr[i];   #maximum ending here
+        if arr[i] > sum_num:
+            sum_num = arr[i]
+        if max_sum < sum_num:     #comparing maximum ending here , maximum so far
+            max_sum = sum_num
+    return max_sum
+
+size = int(input())   
+l = [int(x) for x in input().split()]
+max_sm = kadaneAlgorithm(size,l)
+print(max_sm)

DSA Coding/Array/LargestNumber_formed_from_array.py

@@ -0,0 +1,12 @@
+def largestNumber(self, a):  
+
+        largestnumber =''
+        for i in range(len(a)-1):
+            for j in range(i+1, len(a)):
+                string1 = str(a[i])+str(a[j])
+                string2 = str(a[j])+str(a[i])
+                if int(string2) > int(string1):
+                    a[i] , a[j] = a[j] , a[i]
+        for i in range(len(a)):
+            largestnumber += str(a[i])
+        return int(largestnumber)

DSA Coding/Array/LinearSearch.py

@@ -0,0 +1,13 @@
+#Linear Search
+
+def linear_search(arr, target):
+    for i in range(len(arr)):
+        if arr[i] == target:
+            return i
+    return -1
+
+
+n = int(input("Enter number: "))
+arr = list(map(int, input().split()))
+target = int(input("Enter target: "))
+print(linear_search(arr, target))

DSA Coding/Array/Matrix Difference/script.py

@@ -0,0 +1,45 @@
+r1 = int(input())
+c1 = int(input())
+M1 = []
+M3 = []
+for row_counter in range(r1):
+    matrix_row = input().strip() + " "
+    M_row = []
+    temp = ''
+    counter = 0
+    column_counter = 0
+    while column_counter < c1:
+        if matrix_row[counter] != ' ':
+            temp += matrix_row[counter]
+        else:
+            M_row.append(temp)
+            temp = ''
+            column_counter += 1
+        counter += 1
+    M1.append(M_row)
+    M3.append(M_row)
+r2 = int(input())
+c2 = int(input())
+M2 = []
+for row_counter in range(r2):
+    matrix_row = input().strip() + " "
+    temp = ''
+    counter = 0
+    column_counter = 0
+    while column_counter < c2:
+        if matrix_row[counter] != ' ':
+            temp += matrix_row[counter]
+        else:
+            M2.append(temp)
+            temp = ''
+            column_counter += 1
+        counter += 1
+for row_counter in range(r1):
+        for column_counter in range(c1):
+            if M1[row_counter][column_counter] in M2:
+                M3[row_counter][column_counter] = '0'
+for row_counter in range(r1):
+    for column_counter in range(c1):
+        print(M3[row_counter][column_counter], end=" ")
+    print()
+

DSA Coding/Array/Maximum_Absolute_Difference.py

@@ -0,0 +1,9 @@
+def maxArr(self, A):
+
+        mx = -10000000000
+        for i in range(len(A)):
+            for j in range(len(A)):
+                res = abs(A[i]-A[j])+abs(i-j)
+                if res > mx:
+                    mx = res
+        return mx

DSA Coding/Array/Maximum_Non_Negative_Subarray.py

@@ -0,0 +1,32 @@
+def maxset(self, A):
+        mxsum = -1
+        l = []
+        nl = []
+        for i in range(len(A)):
+            if A[i] < 0:
+                if sum(nl) > mxsum:
+                    mxsum = sum(nl)
+                    l = []
+                    for num in nl:
+                        l.append(num)
+
+                elif sum(nl) == mxsum and len(l) < len(nl):
+                    l = []
+                    for num in nl:
+                        l.append(num)
+
+                nl = []
+            else:
+                nl.append(A[i])
+        if sum(nl) > mxsum:
+            mxsum = sum(nl)
+            l = []
+            for num in nl:
+                l.append(num)
+                nl = []
+        elif sum(nl) == mxsum and len(l) < len(nl):
+            l = []
+            for num in nl:
+                l.append(num)
+                nl = []
+        return l