geeeks 0.1.5

A package to make your life easy.

Geeeks - A simple and helpful package

Install/Upgrade our package

pip install geeeks # install
pip install --upgrade geeeks # upgrade

String Functions

1. Reverse String: reverse(string)

from geeeks import StringFunctions as sf

my_string = "AnyRandomString"
rev = sf.reverse(my_string)

print(rev)
# Output: gnirtSmodnaRynA

2. Make Link: make_link(string)

from geeeks import StringFunctions as sf

my_string = "Any Random String"
link = sf.make_link(my_string)

print(link)
# Output: any-random-string

3. Swap Case: swap_case(string)

from geeeks import StringFunctions as sf

my_string = "Any Random String"
swap = sf.swap_case(my_string)
print(swap) # Output: aNY rANDOM sTRING

4. Make Chunks: make_chunks(string,k)

from geeeks import StringFunctions as sf

my_string = "ABCDEFGHI"
k = 3

print(sf.make_chunks(my_string,k))
# Output: ['ABC','DEF','GHI']

Encryption & Decryption Techniques

1. Caesar Cipher: caesarCipher(s=string(), key=int())

from geeeks import Encryption as encrypt
from geeeks import Decryption as decrypt

string = "this-is-my-secret-message"
key = 4

cipher = encrypt.caesarCipher(string, key)
print(cipher) # Output: xlmw-mw-qc-wigvix-qiwweki

message = decrypt.caesarCipher(cipher, key)
print(message) # Output: this-is-my-secret-message

Advance Algorithms

Divide & Conquer Algorithms

This package (geeeks.DnC_Algo) contains the following functions:

• binary_search(arr, x, low, high)
• bubble_sort(arr)
• merge_sort(arr, low, high)
• min_max(arr, low, high)
• quick_sort(arr, low, high)

1. Binary Search

from geeeks import DnC_Algo as dnc

arr = [1,2,3,4,5]
x = 4 # Element to search
low = 0 # lowest index
high = len(arr)-1 # maximum index

res = dnc.binary_search(arr, x, low, high)
if res != -1:
    print(f"Element is present at index: {res}")
else:
    print("Element is not present in array!")

2. Bubble Sort

from geeeks import DnC_Algo as dnc

arr = [12,9,87,6,43,55,34]
print(dnc.bubble_sort(arr))

3. Merge Sort

from geeeks import DnC_Algo as dnc

arr = [1,2,3,4,5]
low = 0 # lowest index
high = len(arr) # maximum index

print(arr)
dnc.merge_sort(arr, low, high)
print(arr)

4. Minimum & Maximum

from geeeks import DnC_Algo as dnc

arr = [34, 67, 78, 45]
low = 0
high = len(arr) - 1 # maximum index
minimum, maximum = dnc.min_max(arr, low, high)
print(f"Maximum: {maximum}\nMinimum: {minimum}")

5. Quick Sort

from geeeks import DnC_Algo as dnc

arr = [10,9,8,7,6]
low = 0
high = len(arr)-1

print("Before quick sort: {}".format(arr))
dnc.quick_sort(arr, low, high)
print("After quick sort: {}".format(arr))

Dynamic Programming Algorithms

This package (geeeks.DP_Algo) contains the following functions:

• zero_one_knapsack(capacity, weight, profit)
• coin_change(coins, amount)
• longest_common_subsequence(str_a, str_b)
• matrix_multiplication(arr)

1. 0-1 Knapsack Problem

from geeeks import DP_Algo as dp

weight = [2, 3, 4, 5]
profit = [1, 2, 5, 6]
capacity = 8

dp.zero_one_knapsack(capacity, weight, profit)

2. Coin Change Problem

from geeeks import DP_Algo as dp

coins = [2,5,10]
amount = 25
dp.coin_change(coins, amount)

3. Longest Common Subsequence

from geeeks import DP_Algo as dp

A,B = list("algorithm"), list("analysis")
print(dp.longest_common_subsequence(A,B))

4. Matrix Multiplication

from geeeks import DP_Algo as dp

arr=[1,2,3,4,1]
print(dp.matrix_multiplication(arr))

Graph Algorithms

This package (geeeks.Graph_Algo) contains the following functions:

• dijkstra(graph)
• floyd(graph, num_vertices)

1. Dijkstra's Algorithm

from geeeks import Graph_Algo as gp

graph = [[0, 5, 8, 0], [5, 0, 10, 0], [8, 10, 0, 20], [0, 15, 20, 0]]
gp.dijkstra(graph)

2. Floyd-Warshall Algorithm

from geeeks import Graph_Algo as gp
INF = 999
graph = [    [0, 3, INF, 7],
         [8, 0, 2, INF],
         [5, INF, 0, 1],
         [2, INF, INF, 0]]

gp.floyd(graph)

Greedy Algorithms

This package (geeeks.Greedy_Algo) contains the following functions:

• fractional_knapsack(values, weight, max_capacity)
• build_huffman_tree(arr, freq)
• job_scheduling(arr)
• prims_mst(graph)

1. Fractional Knapsack

from geeeks import Greedy_Algo as gd

values = [280, 100, 120, 120]
weight = [40, 10, 20, 24]
max_capacity = 60
gd.fractional_knapsack(values, weight, max_capacity)

2. Huffman Encoding Technique

from geeeks import Greedy_Algo as gd

arr = ['a','b','c','d','e','f']
freq = [40,30,20,5,3,2]
gd.build_huffman_tree(arr, freq)

3. Job Scheduling

from geeeks import Greedy_Algo as gd

# follow this structure for the data
arr = [['j1', 5, 200],
       ['j2', 3, 180],
       ['j3', 3, 190],
       ['j4', 2, 300],
       ['j5', 4, 120],
       ['j6', 2, 100]
       ]

gd.job_scheduling(arr)

4. Prim's Algorithm

from geeeks import Greedy_Algo as gd

graph = [[0,5,8,0],[5,0,10,0],[8,10,0,20],[0,15,20,0]]
print("MST acc. to Prim's is: {}".format(gd.prims_mst(graph)))