Rapidkode: Hazlo bien la primera vez
Rapidkode es un paquete de Python que proporciona estructuras de datos rápidas, flexibles y expresivas, alogoritmos diseñados para hacer que trabajar con programación competitiva y codificación sea fácil e intuitiva. Su objetivo es ser el bloque de construcción de alto nivel fundamental para la programación competitiva en Python. Con Rapidkode puede realizar algoritmos complejos en menos tiempo, todos los algoritmos están optimizados al máximo para reducir la complejidad de tiempo para que se destaque en la junta de líderes. No hay más tiempo desperdiciando escribiendo enormes fucks de código y depurándolos más tarde, con Rapidkode todo sucede a su alcance con una sola línea de código. El objetivo de Rapidkode es ayudar a los principiantes a comenzar en la programación competitiva, comprender la importancia del tiempo y el espacio. El lema de hacer Rapidkode es 'hacerlo bien la primera vez' en lugar de pasar 10 de preciosos minutos en funciones de Utily.
Instalación:
o
Para obtener problemas, informes de errores y contribuciones, visite el repositorio de desarrollo -> Haga clic aquí
Funciones disponibles:
Funciones numéricas:
| sintaxis | operación |
|---|
| números.gen_sparsenum_upto (x) | genera un número escaso hasta el rango dado |
| números.get_sparsenum_after (n) | Devuelve el número escaso de éxito para el número dado |
| Numbers.CheckPrime (x) | Devuelve verdadero si el número es primo |
| Number.getPrimes.Generate (x) | Devuelve los primeros x números primos |
| Numbers.getPrimes.upto (x) | Devuelve los números primos hasta el rango dado |
| Number.getPrimes.inrange (x, y) | Devuelve los números primos en el rango dado |
| números.fib.getElement (x) | Devuelve el número de fibonacci x'th |
| números.fib.generate (x) | Devuelve los primeros x números de fibonacci |
Ejemplo:
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 )
Producción:
[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]
Sistema de números - Funciones de conversión:
| Sintaxis | Operación |
|---|
| convert (x, 'sys'). a ('new_sys') | Convierte X de SYS a SYS nuevo |
| Ejemplo: | |
| Convertir (9845, 'dec'). a ('bin') | Convierte 9845 de decimal a binario |
| Convertir (3745, 'Oct'). A ('Hex') | Convierte 3745 de octal a hexadecimal |
- Puede reemplazar con
sys con ['bin', 'dec', 'oct', 'hex'] y new_sys con ['bin', 'dec', 'oct', 'hex'], para hacer conversiones numéricas.
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 )
Producción:
11111011101
7dd
2013
2972
24562
10100101110010
Algoritmos de búsqueda:
| Técnica | Sintaxis | Operación | Complejidad del tiempo |
|---|
| Búsqueda lineal | Linear.Search (arr, x) | Devuelve la posición de x en arr | En) |
| Búsqueda binaria | binary.search (arr, x) | Devuelve la posición de x en arr | O (log n) |
| Búsqueda de saltos | Jump.Search (arr, x) | Devuelve la posición de x en arr | O (√ n) |
| Búsqueda de interpolación | Interpolation.Search (arr, x) | Devuelve la posición de x en arr | O (log2 (log2 n)) |
| Búsqueda exponencial | exponencial.search (arr, x) | Devuelve la posición de x en arr | O (log2 i) |
| Búsqueda ternaria | ternary.search (arr, x) | Devuelve la posición de x en arr | O (log3 n) |
Additonally puede usar:
| Función | Operación |
|---|
| .espectáculo() | Imprime el código en la terminal |
| .info () | Da la breve información |
| .algo () | Imprime el algoritmo de paso |
Ejemplo:
import rapidkode as rk
> >> rk . binary . show ()
> >> rk . binary . info ()
> >> rk . binary . algo ()
Producción:
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.
Las tres funciones .show() , .info() , .algo() se pueden usar para las 6 técnicas de búsqueda.
Algoritmos de clasificación:
| Técnica | Sintaxis | Operación | Complejidad del tiempo |
|---|
| Clasificación de selección | selección.sort (arr) | Clasifica y devuelve la matriz dada | O (n^2) |
| Burbuja | Bubble.sort (arr) | Clasifica y devuelve la matriz dada | O (n^2) |
| Clasificación de inserción | inserción.sort (arr) | Clasifica y devuelve la matriz dada | O (n^2) |
| Fusionar | fusionar.sort (arr) | Clasifica y devuelve la matriz dada | O (n log (n)) |
| Sort de montón | montón.sort (arr) | Clasifica y devuelve la matriz dada | O (n log (n)) |
| Clasificación rápida | Quick.sort (inicio, finalización, arr) | Clasifica y devuelve la matriz dada | O (n^2) |
| Clasificar | Count.sort (arr) | Clasifica y devuelve la matriz dada | O (N+K) |
| Radix Sort | radix.sort (arr) | Clasifica y devuelve la matriz dada | O (NK) |
| Clasificación de cubos | bucket.sort (arr) | Clasifica y devuelve la matriz dada | O (N + K) |
| Clasificar con cáscara | shell.sort (arr) | Clasifica y devuelve la matriz dada | O (nlog n) |
| Ordenar | peiness (arr) | Clasifica y devuelve la matriz dada | O (n log n) |
| Clasificación de paloma | Pigeonhole.sort (arr) | Clasifica y devuelve la matriz dada | O (N + N) |
| Clasificación de ciclo | ciclo.sort (arr) | Clasifica y devuelve la matriz dada | O (N2) |
Additonally puede usar:
| Función | Operación |
|---|
| .espectáculo() | Imprime el código en la terminal |
| .info () | Da la breve información |
| .algo () | Imprime el algoritmo de paso |
Ejemplo:
import rapidkode as rk
> >> rk . count . show ()
> >> rk . count . info ()
> >> rk . count . algo ()
Producción:
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.
Las tres funciones .show() , .info() , .algo() se pueden usar para las 13 técnicas de clasificación.
Funciones gráficas:
| Sintaxis | Operación |
|---|
| .BuildEdge (u, v) | Crear un borde gráfico |
| .BuildMultiedge ([[]) | Crea un gráfico con la lista de coords dada |
| .Bfs (x) | Realizar la primera búsqueda de amplitud |
| .Dfs (x) | Realiza la primera búsqueda de profundidad |
| .findap () | Devuelve el punto de articulación del gráfico |
Ejemplo:
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 ())
Producción:
['-->', 2, '-->', 0, '-->', 3, '-->', 1]
['-->', 2, '-->', 0, '-->', 1, '-->', 3]
2
Funciones del patrón:
La siguiente función utiliza el algoritmo Rabin-Karp, que es un algoritmo utilizado para buscar patrones de búsqueda/coincidencia en el texto utilizando una función hash. A diferencia del algoritmo de coincidencia de cadenas ingenuas, no viaja a través de cada carácter de la fase inicial, sino que filtra los caracteres que no coinciden y luego realiza la comparación.
| Sintaxis | Operación |
|---|
| patrón. | Devuelve verdadero si la cadena A está presente en la cadena B |
| patrón. Whereis (a) .inn (b) | Devuelve la posición de índice de la cadena A en la cadena B |
Ejemplo:
import rapidkode as rk
a = 'sasi'
b = 'satyasasivatsal'
print ( rk . isthere ( a ). inn ( b ))
print ( rk . whereis ( a ). inn ( b ))
Producción:
Funciones de LinkedList:
| Operación | Sintaxis |
|---|
| .ins_beg (nodo) | Inserta un nuevo nodo al comienzo |
| .ins_end (nodo) | Inserta un nuevo nodo al final |
| .ins_after (pos, nodo) | Inserta un nuevo nodo después del nodo especificado |
| .ins_before (pos, nodo) | Inserta un nuevo nodo antes del nodo especificado |
| .del_node (nodo) | Elimina el nodo especificado |
| .return_as_list () | Devuelve LinkedList como Lista de Python |
Ejemplo:
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 )
Producción :
a -> b -> c -> d -> e -> f -> g -> None
Ejemplo -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 )
Producción :
A -> a -> C -> c -> d -> e -> E -> f -> g -> G -> None
['A', 'a', 'C', 'c', 'd', 'e', 'E', 'f', 'g', 'G', 'None']
Fuctiones de manipulación de bits:
| Sintaxis | Operación |
|---|
| bits.toggle_bits (x) | Alternar los bits y bits no establecidos |
| bits.convert_to_bin (x) | Convierte un número dado en binario |
| bits.counsetbits (x) | Devuelve el número de bits establecidos en un número de DEC |
| bits.rotate_byleft (x, d) | Gira los bits a la izquierda por los tiempos D |
| bits.rotate_byright (x, d) | Gira los bits a la izquierda por los tiempos D |
| bits.countflips (x, y) | Devuelve el número de flips para hacer x como y |
Ejemplo:
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 )
Producción:
960632
11010101010010110100
8474306
13978432
54603
7
Otras funciones misceláneas:
| Sintaxis | Operación |
|---|
| .showsieves () | Imprima el código de tamices para encontrar el número primo en la terminal |
| getPrimeFactors.fornum (x) | Devuelve una lista de factores primos para el número dado |
| findgcdof (x, y) | Devuelve GCD de los números dados |
| findinversions.forr (arr) | Devuelve qué tan cerca está la matriz de ser ordenadas |
| catlan_numbers.getElement (x) | Devuelve el número de X'th Catlan |
| catlan_numbers.gen (x) | Devuelve una lista de First X Catlan_numbers |
Ejemplo:
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 )
Producción:
[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]
Contribuyendo a RapidKode
- Todas las contribuciones, informes de errores, correcciones de errores, mejoras de documentación, mejoras e ideas son bienvenidas.
- Plantear un problema si encuentra algún problema
- Si le gusta contribuir, el repositorio plantea un problema antes de hacer una solicitud de extracción, será fácil para administrar
- Créditos de logotipo y encabezado -> M.Sri Harsha❤️
¡Feliz Koding Rapid!
