rapidkode 1.0.6

Description:

rapidkode 1.0.6

RapidKode: get it right the first time
RapidKode is a Python package that provides fast, flexible, and expressive data structures,alogorithms designed to make working with both competitive programming and coding easy and intuitive. It aims to be the fundamental high-level building block for competitive programming in Python.With RapidKode you can perform complex algorithms in less time, all the algorithms are optimized to their finest to reduce time complexity to make you stand out in the leader board. There is no more time wasting writing huge chucks of code and debugging them later, With RapidKode everything happens at your fingertips with just a single line of code. The aim of Rapidkode is to help beginners get started in competative programing, understand the importance of time and space. The motto of making Rapidkode is to 'Get it right the first time' instead of spending 10's of precious minutes on util functions.
Installation:


Install from the official pypi website -> Click Here


or
$ pip install rapidkode

For issues,bug reports and contributions visit the development repo --> Click Here
Available Functions :
Number functions :



syntax
operation




numbers.gen_sparsenum_upto(x)
generates sparse number upto the given range


numbers.get_sparsenum_after(n)
Returns the succeding sparse number for the given number


numbers.checkprime(x)
Returns True if number is prime


numbers.getprimes.generate(x)
Returns first x prime numbers


numbers.getprimes.upto(x)
Returns prime numbers upto given range


numbers.getprimes.inrange(x,y)
Returns prime numbers in the given range


numbers.fib.getelement(x)
Returns x'th fibonacci number


numbers.fib.generate(x)
Returns first x fibonacci numbers



Example:
import rapidkode as rk

var = rk.numbers.gen_sparsenum_upto(100)
print(var)

var = rk.numbers.get_sparsenum_after(3289)
print(var)

var = rk.numbers.checkprime(8364)
print(var)

var = rk.numbers.getprimes.generate(100)
print(var)

var = rk.numbers.getprimes.inrange(100,500)
print(var)

var = rk.numbers.fib.getelement(58)
print(var)

var = rk.numbers.fib.generate(25)
print(var)

Output:
[0, 1, 2, 4, 5, 8, 9, 10, 16, 17, 18, 20, 21, 32, 33, 34, 36, 37, 40, 41, 42, 64, 65, 66, 68, 69, 72, 73, 74, 80, 81, 82, 84, 85, 128]

4096

False

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541]

[101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]

365435296162

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368]


Number System - Conversion functions:



Syntax
Operation




convert(x,'sys').to('new_sys')
Converts x from sys to new sys


Example:



convert(9845,'dec').to('bin')
Converts 9845 from Decimal to Binary


convert(3745,'oct').to('hex')
Converts 3745 from Octal to Hexadecimal




You can replace with sys with ['bin','dec','oct','hex'] and new_sys with ['bin','dec','oct','hex'], to make number conversions.

import rapidkode as rk

converted_num_1 = rk.convert(2013,'dec').to('bin')
print(converted_num_1)

converted_num_2 = rk.convert(11111011101,'bin').to('hex')
print(converted_num_2)

converted_num_3 = rk.convert('7dd','hex').to('dec')
print(converted_num_3)

converted_num_4 = rk.convert(5634,'oct').to('dec')
print(converted_num_4)

converted_num_5 = rk.convert(2972,'hex').to('oct')
print(converted_num_5)

converted_num_6 = rk.convert(24562,'oct').to('bin')
print(converted_num_6)

Output:
11111011101
7dd
2013
2972
24562
10100101110010

Searching Algorithms :



Technique
Syntax
Operation
Time Complexity




Linear Search
linear.search(arr,x)
Returns position of x in arr
O(n)


Binary Search
binary.search(arr,x)
Returns position of x in arr
O(log n)


Jump Search
jump.search(arr,x)
Returns position of x in arr
O(√ n)


Interpolation Search
interpolation.search(arr,x)
Returns position of x in arr
O(log2(log2 n))


Exponential Search
exponential.search(arr,x)
Returns position of x in arr
O(log2 i)


Ternary Search
ternary.search(arr,x)
Returns position of x in arr
O(log3 n)



additonally you can use:



Function
Operation




.show()
prints the code in the terminal


.info()
Gives the brief info


.algo()
prints the step wise algorithm



Example:
import rapidkode as rk

>>> rk.binary.show()
>>> rk.binary.info()
>>> rk.binary.algo()

Output:
def binarysearch(arr, x):
l = 0
r = len(arr)-1
while l <= r:

mid = l + (r - l) // 2
if arr[mid] == x:
return mid
elif arr[mid] < x:
l = mid + 1
else:
r = mid - 1
return "element not found"

Binary search is the search technique that works efficiently on sorted lists
. Hence, to search an element into some list using the binary search technique, we must ensure that the list is sorted
. Binary search follows the divide and conquer approach in which the list is divided into two halves, and the item is compared with the middle element of the list
. If the match is found then, the location of the middle element is returned
. Otherwise, we search into either of the halves depending upon the result produced through the match

Algorithm

Step 1 - Read the search element from the user.

Step 2 - Find the middle element in the sorted list.

Step 3 - Compare the search element with the middle element in the sorted list.

Step 4 - If both are matched, then display "Given element is found!!!" and terminate the function.

Step 5 - If both are not matched, then check whether the search element is smaller or larger than the middle element.

Step 6 - If the search element is smaller than middle element, repeat steps 2, 3, 4 and 5 for the left sublist of the middle element.

Step 7 - If the search element is larger than middle element, repeat steps 2, 3, 4 and 5 for the right sublist of the middle element.

Step 8 - Repeat the same process until we find the search element in the list or until sublist contains only one element.

Step 9 - If that element also doesn't match with the search element, then display "Element is not found in the list!!!" and terminate the function.

The three functions .show(), .info(), .algo() can be used for all the 6 searching techniques.
Sorting Algorithms :



Technique
Syntax
Operation
Time Complexity




Selection Sort
selection.sort(arr)
Sorts and Returns the given array
O(n^2)


Bubble Sort
bubble.sort(arr)
Sorts and Returns the given array
O(n^2)


Insertion Sort
insertion.sort(arr)
Sorts and Returns the given array
O(n^2)


Merge Sort
merge.sort(arr)
Sorts and Returns the given array
O(n log(n))


Heap Sort
heap.sort(arr)
Sorts and Returns the given array
O(n log(n))


Quick Sort
quick.sort(start,end,arr)
Sorts and Returns the given array
O(n^2)


Count Sort
count.sort(arr)
Sorts and Returns the given array
O(n+k)


Radix Sort
radix.sort(arr)
Sorts and Returns the given array
O(nk)


Bucket Sort
bucket.sort(arr)
Sorts and Returns the given array
O(n + k)


Shell Sort
shell.sort(arr)
Sorts and Returns the given array
O(nlog n)


Comb Sort
comb.sort(arr)
Sorts and Returns the given array
O(n log n)


Pigeongole Sort
pigeonhole.sort(arr)
Sorts and Returns the given array
O(n + N)


Cycle Sort
cycle.sort(arr)
Sorts and Returns the given array
O(n2)



additonally you can use:



Function
Operation




.show()
prints the code in the terminal


.info()
Gives the brief info


.algo()
prints the step wise algorithm



Example:
import rapidkode as rk

>>> rk.count.show()
>>> rk.count.info()
>>> rk.count.algo()

Output:
def countsort(arr):
output = [0 for i in range(len(arr))]
count = [0 for i in range(256)]
array = [0 for _ in arr]
for i in arr:
count[i] += 1
for i in range(256):
count[i] += count[i-1]
for i in range(len(arr)):
output[count[arr[i]]-1] = arr[i]
count[arr[i]] -= 1
for i in range(len(arr)):
array[i] = output[i]
return array

Counting sort is a sorting algorithm that sorts the elements of an array by counting the number of occurrences of each unique element in the array
. The count is stored in an auxiliary array and the sorting is done by mapping the count as an index of the auxiliary array
. Counting sort is a sorting technique based on keys between a specific range
. It works by counting the number of objects having distinct key values (kind of hashing)
. Then doing some arithmetic to calculate the position of each object in the output sequence

Algorithm

step 1 - Find out the maximum element (let it be max) from the given array.

step 2 - Initialize an array of length max+1 with all elements 0.
This array is used for storing the count of the elements in the array.

step 3 - Store the count of each element at their respective index in count array

For example: if the count of element 3 is 2 then, 2 is stored in the 3rd position of count array.
If element "5" is not present in the array, then 0 is stored in 5th position.

step 4 - Store cumulative sum of the elements of the count array.
It helps in placing the elements into the correct index of the sorted array.

step 5 - Find the index of each element of the original array in the count array.
This gives the cumulative count. Place the element at the index calculated as shown in figure below.

step 6 - After placing each element at its correct position, decrease its count by one.


The three functions .show(), .info(), .algo() can be used for all the 13 sorting techniques.
Graph Functions :



Syntax
Operation




.buildedge(u,v)
Create an Graph Edge


.buildmultiedge([])
Creates an Graph with given Coord list


.BFS(x)
Perform Breadth First Search


.DFS(x)
Performs Depth First Search


.findAP()
Returns the Articulation Point of the graph



Example:
import rapidkode as rk

# make graph object with graph() class

my_graph = rk.graph()

# adding one edge at a time
my_graph.buildedge(0, 1)
my_graph.buildedge(0, 2)
my_graph.buildedge(1, 2)
my_graph.buildedge(2, 0)
my_graph.buildedge(2, 3)
my_graph.buildedge(3, 3)

import rapidkode as rk

# make graph object with graph() class

my_graph = rk.graph()

# adding multiple edges at once

my_graph.buildmultiedge([0,1,0,2,1,2,2,0,2,3,3,3])

import rapidkode as rk

# make graph object with graph() class

my_graph = rk.graph()

my_graph.buildmultiedge([0,1,0,2,1,2,2,0,2,3,3,3])

# performing BFS from edge 2
print(my_graph.BFS(2))

# performing DFS from edge 2
print(my_graph.DFS(2))

# finding the Articulation Point
print(my_graph.findAP())

Output:
['-->', 2, '-->', 0, '-->', 3, '-->', 1]

['-->', 2, '-->', 0, '-->', 1, '-->', 3]

2

Pattern Functions :
The following function uses Rabin-Karp algorithm which is an algorithm used for searching/matching patterns in the text using a hash function. Unlike Naive string matching algorithm, it does not travel through every character in the initial phase rather it filters the characters that do not match and then performs the comparison.



Syntax
Operation




pattern.isthere(a).inn(b)
Returns true if string a is present in string b


pattern.whereis(a).inn(b)
Returns the index position of string a in string b



Example:
import rapidkode as rk

a = 'sasi'
b = 'satyasasivatsal'

print(rk.isthere(a).inn(b))
print(rk.whereis(a).inn(b))

Output:
True

4

Linkedlist Functions:



Operation
Syntax




.ins_beg(node)
Inserts a new node at beginning


.ins_end(node)
Inserts a new node at the end


.ins_after(pos,node)
Inserts a new node after the node specified


.ins_before(pos,node)
Inserts a new node before the specified node


.del_node(node)
Deletes the specified node


.return_as_list()
Returns LinkedList as python List



Example:
import rapidkode as rk

my_list = rk.linkedlist()

my_list.head = rk.node('a')

s1 = rk.node('b')
s2 = rk.node('c')
s3 = rk.node('d')
s4 = rk.node('e')
s5 = rk.node('f')
s6 = rk.node('g')

my_list.head.next = s1
s1.next = s2
s2.next = s3
s3.next = s4
s4.next = s5
s5.next = s6

print(my_list)

Output :
a -> b -> c -> d -> e -> f -> g -> None

Example -2 :
# insertion at beginning
my_list.ins_beg(rk.node('A'))

# insertion at end
my_list.ins_end(rk.node('G'))

# insertion at positiom
my_list.ins_after('e',rk.node('E'))

# insertion at position
my_list.ins_before('c',rk.node('C'))

# deletion of ndoe
my_list.del_node('b')

# returning as list
my_listt = my_list.return_as_list()

print(my_list)

print(my_listt)

Output :
A -> a -> C -> c -> d -> e -> E -> f -> g -> G -> None

['A', 'a', 'C', 'c', 'd', 'e', 'E', 'f', 'g', 'G', 'None']

Bit manipulation Fuctions:



Syntax
Operation




bits.toggle_bits(x)
Toggles the set bits and non set bits


bits.convert_to_bin(x)
Converts a given number into binary


bits.counsetbits(x)
Returns the no.of set bits in a dec number


bits.rotate_byleft(x,d)
Rotates the bits to left by d times


bits.rotate_byright(x,d)
Rotates the bits to left by d times


bits.countflips(x,y)
Returns the no.of flips to make x as y



Example:
import rapidkode as rk

var = rk.bits.toggle_bits(873652)
print(var)

var = rk.bits.convert_to_bin(873652)
print(var)

var = rk.bits.countsetbits(873652)
print(var)

var = rk.bits.rotate_byleft(873652,4)
print(var)

var = rk.bits.rotate_byright(873652,4)
print(var)

var = rk.bits.countflips(8934756,873652)
print(var)

Output:
960632

11010101010010110100

8474306

13978432

54603

7

Other misc Functions:



Syntax
Operation




.showsieves()
Prints Sieves code for finding prime number in terminal


getprimefactors.fornum(x)
Returns a list of prime factors for given number


findgcdof(x,y)
Returns GCD of the given numbers


findinversions.forr(arr)
Returns how close the array is from being sorted


catlan_numbers.getelement(x)
Returns the x'th Catlan Number


catlan_numbers.gen(x)
Returns a list of first x Catlan_numbers



Example:
import rapidkode as rk

var = rk.getprimefactors.fornum(6754)
print(var)

var = rk.findgcdof(97345435,8764897)
print(var)

var = rk.findinversions.forr([1, 20, 6, 4, 5])
print(var)

var = rk.catlan_numbers.getelement(15)
print(var)

var = rk.catlan_numbers.gen(28)
print(var)

Output:
[2, 11, 307.0]

1

5

9694845.0

[1.0, 1.0, 2.0, 5.0, 14.0, 42.0, 132.0, 429.0, 1430.0, 4862.0, 16796.0, 58786.0, 208012.0, 742900.0, 2674440.0, 9694845.0, 35357670.0, 129644790.0, 477638700.0, 1767263190.0, 6564120420.0, 24466267020.0, 91482563640.0, 343059613650.0, 1289904147324.0, 4861946401452.0, 18367353072152.0, 69533550916004.0]

Contributing to RapidKode

All contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome.
Raise an issue if you find any problem
If you like to contribute, fork the repo raise an issue before making a pull request, it will be easy for managing
Logo and header credits --> M.Sri Harsha❤️

Happy Rapid Koding!!