Added 2 nondeterministic algorithms and changed swap methods

Author: Мето Трајковски

Arrays/find_first_missing_positive.py

@@ -38,9 +38,7 @@ def find_first_missing_1(a):
                 break
 
             # swap elements
-            temp = a[i]
-            a[i] = a[swap]
-            a[swap] = temp
+            a[i], a[swap] = a[swap], a[i]
 
     for i in range(n):
         if a[i] - 1 != i:
@@ -107,19 +105,19 @@ def find_first_missing_2(a):
 print(find_first_missing_2(list(test)))
 
 # Test 5
-# Correct result => 5
+# Correct result => 1
 test = [-4, -1, -3, -1]
 print(find_first_missing_1(list(test)))
 print(find_first_missing_2(list(test)))
 
 # Test 6
-# Correct result => 6
+# Correct result => 3
 test = [2, 1, 2, -1, 0, 20]
 print(find_first_missing_1(list(test)))
 print(find_first_missing_2(list(test)))
 
 # Test 7
-# Correct result => 7
+# Correct result => 3
 test = [1, 2, 5, 5, 1, 2]
 print(find_first_missing_1(list(test)))
 print(find_first_missing_2(list(test)))

Arrays/k_closest_points.py

@@ -63,9 +63,7 @@ def pivoting(arr, left, right, pt):
 
 def swap(arr, i, j):
     # swaps two elements in an array
-    temp = arr[i]
-    arr[i] = arr[j]
-    arr[j] = temp
+    arr[i], arr[j] = arr[j], arr[i]
 
 def sqr_dist(a, b):
     # no need from the square root

Arrays/kth_smallest.py

@@ -67,9 +67,7 @@ def pivoting(arr, left, right):
 
 def swap(arr, i, j):
     # swaps two elements in an array
-    temp = arr[i]
-    arr[i] = arr[j]
-    arr[j] = temp
+    arr[i], arr[j] = arr[j], arr[i]
 
 
 ##############

Arrays/min_swaps.py

@@ -35,9 +35,7 @@ def min_swaps(a):
         while a[i] - 1 != i:
             swap = a[i] - 1
             # swap the elements
-            tmp = a[swap]
-            a[swap] = a[i]
-            a[i] = tmp
+            a[swap], a[i] = a[i], a[swap]
 
             swaps += 1
 

Arrays/reverse_array.py

@@ -36,9 +36,12 @@ def reverse_arr(arr):
 
 def swap(arr, i, j):
     # swapping two elements from a same array
+    arr[i], arr[j] = arr[j], arr[i]
+    '''same as
     temp = arr[i]
     arr[i] = arr[j]
     arr[j] = temp
+    '''
 
 
 ###########

Arrays/reverse_ascending_sublists.py

@@ -41,18 +41,12 @@ def reverse_arr(arr, start, end):
     while start < end:
         # reverse the array from the start index to the end index by
         # swaping each element with the pair from the other part of the array
-        swap(arr, start, end)
+        arr[start], arr[end] = arr[end], arr[start]
         start += 1
         end -= 1
 
     return arr
 
-def swap(arr, i, j):
-    # swapping two elements from a same array
-    temp = arr[i]
-    arr[i] = arr[j]
-    arr[j] = temp
-
 
 ###########
 # Testing #

Arrays/secret_santa.py

@@ -0,0 +1,58 @@
+'''
+Secret Santa
+
+Secret Santa is a game in which a group of friends or colleagues exchange Christmas presents anonymously,
+each member of the group being assigned another member for whom to provide a small gift.
+You're given a list of names, make a random pairs (each participant should have another name as pair).
+Return an array with pairs represented as tuples.
+
+Input: ['a', 'b', 'c']
+Output: This is a nondeterministic algorithm, more solutions exists, here are 2 possible solutions:
+    [('a', 'b'), ('b', 'c'), ('c', 'a')], [('a', 'c'), ('c', 'b'), ('b', 'a')]
+
+=========================================
+Shuffle the array (this algorithm is explained in shuffle_array.py) and pair the current element
+with the next element (neighbouring).
+    Time Complexity:    O(N)
+    Space Complexity:   O(N)
+'''
+
+
+############
+# Solution #
+############
+
+from random import randint
+
+def secret_santa(names):
+    # or use shuffle method from random module (from random import shuffle)
+    shuffle_array(names)
+    pairs = []
+
+    n = len(names)
+    prev = names[-1] # or names[n - 1]
+
+    for curr in names:
+        pairs.append((prev, curr))
+        prev = curr
+
+    return pairs
+
+def shuffle_array(arr):
+    n = len(arr)
+
+    for i in range(n):
+        rand = randint(i, n - 1) # or randint(0, i) it's same
+        arr[i], arr[rand] = arr[rand], arr[i] # swap elements
+
+    # the original arr is already changed
+    return arr
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => nondeterministic algorithm, many solutions exist
+print(secret_santa(['a', 'b', 'c']))

Arrays/shuffle_array.py

@@ -0,0 +1,47 @@
+'''
+Shuffle an Array
+
+Given an array (array elements could be of any type/kind),
+write a program to generate in-place a random permutation of array elements.
+This question is also asked as “shuffle a deck of cards” or “randomize a given array”.
+Here shuffle means that every permutation of array element should equally likely.
+
+Input: [1, 2, 3]
+Output: This is a nondeterministic algorithm, N! solutions/permutations exists.
+    In this case 3! = 6. All permutations are a valid solution.
+    [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]
+
+=========================================
+Easy in-place solution, choose an random index/position from I (I is the current position) to N-1
+(or choose from 0 to I, it's same), swap the element at random position with the element at I position.
+Increase I and continue with the same algorithm.
+Note: In Python there is already implemented shuffle (in random module "from random import shuffle") method
+    which works in similar way. But it's easy to be implemented and I wanted to show how to implement it.
+    Time Complexity:    O(N)
+    Space Complexity:   O(1)
+'''
+
+
+############
+# Solution #
+############
+
+from random import randint
+
+def shuffle_array(arr):
+    n = len(arr)
+
+    for i in range(n):
+        rand = randint(i, n - 1) # or randint(0, i) it's same
+        arr[i], arr[rand] = arr[rand], arr[i] # swap elements
+
+    # the original arr is already changed
+    return arr
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => One of these: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]
+print(shuffle_array([1, 2, 3]))

Arrays/sort_rgb_array.py

@@ -33,9 +33,7 @@ def sort_rgb_array(arr):
     for i in range(n):
         # swap the element and move the pointer
         if arr[i] == 'R':
-            temp = arr[i]
-            arr[i] = arr[r]
-            arr[r] = temp
+            swap(arr, i, r)
             r += 1
 
         # move pointer
@@ -44,9 +42,7 @@ def sort_rgb_array(arr):
 
         # swap the element and move the pointer
         if arr[i] == 'G':
-            temp = arr[i]
-            arr[i] = arr[g]
-            arr[g] = temp
+            swap(arr, i, g)
             g += 1
 
         # move pointer
@@ -55,13 +51,15 @@ def sort_rgb_array(arr):
 
         # swap the element and move the pointer
         if arr[i] == 'B':
-            temp = arr[i]
-            arr[i] = arr[b]
-            arr[b] = temp
+            swap(arr, i, b)
             b += 1
 
     return arr
 
+def swap(arr, i, j):
+    # swaps two elements in an array
+    arr[i], arr[j] = arr[j], arr[i]
+
 
 ##############
 # Solution 2 #

Arrays/top_k_frequent_elements.py

@@ -11,11 +11,11 @@
 Output: [1]
 
 =========================================
-Using Min Priority Queue, in each step add an element with its frequency and remove the element with the smallest frequency 
-if there are more than K elements inside the Priority Queue. This solution isn't much faster than sorting the frequencies. 
+Using Min Priority Queue, in each step add an element with its frequency and remove the element with the smallest frequency
+if there are more than K elements inside the Priority Queue. This solution isn't much faster than sorting the frequencies.
     Time Complexity:    O(U LogK)   , U in this case is the number of unique elements (but all elements from the array could be unique, so because of that U can be equal to N)
     Space Complexity:   O(N)
-Using pivoting, this solution is based on the quick sort algorithm (divide and conquer). 
+Using pivoting, this solution is based on the quick sort algorithm (divide and conquer).
 Same pivoting solution as the nth_smallest.py.
     Time Complexity:    O(U)
     Space Complexity:   O(N)
@@ -30,7 +30,7 @@
 
 # priority queue comparator class
 # acctualy in this case you don't need a comparator class, because the elements are tuples
-# and comparison operator can work with tuples 
+# and comparison operator can work with tuples
 # (The comparison starts with a first element of each tuple. If they do not compare to =,< or > then it proceed to the second element and so on.)
 class PQElement:
     def __init__(self, el):
@@ -146,9 +146,7 @@ def pivoting(arr, left, right):
 
 def swap(arr, i, j):
     # swaps two elements in an array
-    temp = arr[i]
-    arr[i] = arr[j]
-    arr[j] = temp
+    arr[i], arr[j] = arr[j], arr[i]
 
 
 ###########