SYMBOL INDEX (231 symbols across 47 files)

FILE: Algorithms-Illuminated/src/main.rs
  function main (line 1) | fn main() {

FILE: _challenge_problems/index_equal_element.py
  function same (line 15) | def same(A):
  function run (line 25) | def run(A, ok=False):

FILE: _challenge_problems/unimodal_array.py
  function best (line 4) | def best(A):
  function run (line 14) | def run(A):
  function random_unimodal (line 40) | def random_unimodal(seed=0):

FILE: bellman_ford/main.cpp
  function VI (line 19) | VI bell(Edges& E, int N, int start = 1, int INF = 1e6) {
  function VI (line 30) | VI spfa(Edges& E, int N, int start = 1, int INF = 1e6, AdjList adj = {}) {
  function VI (line 45) | VI run(const string& filename) {
  function main (line 66) | int main() {

FILE: bellman_ford/main.py
  function bell (line 4) | def bell(E, N, start = 1, INF = int(1e6)):
  function spfa (line 15) | def spfa(E, N, start = 1, INF = int(1e6)):
  function run (line 29) | def run(filename):

FILE: closest_pair/naive.py
  function dist (line 5) | def dist(i, j):

FILE: closest_pair/recursive.py
  function distance (line 3) | def distance(a, b):
  function split (line 9) | def split(Px, Py, d):
  function best (line 28) | def best(P):
  function go (line 40) | def go(Px, Py):
  function run (line 64) | def run(points, expected_best_pair):

FILE: dijkstra/main.cpp
  class BaseSolution (line 15) | class BaseSolution {
  class NaiveSolution (line 22) | class NaiveSolution : public BaseSolution {
    method Distance (line 26) | Distance dijkstra(Edges& E) {
    method string (line 50) | string run(string filename, Queries&& queries) {
  class HeapSolution (line 67) | class HeapSolution : public BaseSolution {
    method Distance (line 73) | Distance dijkstra(AdjList& adj) {
    method string (line 91) | string run(string filename, Queries&& queries) {
  function run (line 108) | void run(BaseSolution&& solution) {
  function main (line 113) | int main() {

FILE: dijkstra/main.js
  constant INF (line 3) | let INF = Number(1e9 + 7);
  class NaiveSolution (line 5) | class NaiveSolution {
    method dijkstra (line 6) | dijkstra(E) {
    method run (line 30) | run(filename, queries) {
  class HeapSolution (line 81) | class HeapSolution {
    method dijkstra (line 82) | dijkstra(adj) {
    method run (line 97) | run(filename, queries) {

FILE: dijkstra/main.py
  class BaseSolution (line 6) | class BaseSolution(ABC):
    method run (line 8) | def run(self, filename, queries):
  class NaiveSolution (line 11) | class NaiveSolution(BaseSolution):
    method dijkstra (line 12) | def dijkstra(self, E):
    method run (line 33) | def run(self, filename, queries):
  class HeapSolution (line 48) | class HeapSolution(BaseSolution):
    method dijkstra (line 49) | def dijkstra(self, adj, start = 1):
    method run (line 62) | def run(self, filename, queries):
  function run (line 79) | def run(solution):

FILE: floyd_warshall/main.cpp
  function string (line 34) | string key(int i, int j) {
  function VVL (line 39) | VVL floyd_warshall(Edges& E, int N) {
  function VVL (line 55) | VVL floyd_warshall_memopt(Edges& E, int N) {
  function run (line 74) | void run(const string& filename) {
  function main (line 99) | int main() {

FILE: floyd_warshall/main.py
  function floyd_warshall (line 18) | def floyd_warshall(E, N):
  function floyd_warshall_memopt (line 32) | def floyd_warshall_memopt(E, N):
  function run (line 48) | def run(filename):

FILE: greedy_scheduling/main.cpp
  type Job (line 9) | struct Job {
    method Job (line 11) | Job(LL weight, LL length) : weight{ weight }, length{ length } {}
  class Solution (line 15) | class Solution {
    method Pair (line 18) | Pair minSum(Jobs& jobs) {
    method LL (line 33) | LL calcSum(Jobs& jobs, Comp comp, LL time = 0LL) {
  function run (line 41) | void run(const string& filename) {
  function main (line 50) | int main() {

FILE: greedy_scheduling/main.js
  class Job (line 3) | class Job {
    method constructor (line 4) | constructor(weight, length) {
  class Solution (line 10) | class Solution {
    method minSum (line 11) | minSum(jobs) {
    method _calcSum (line 24) | _calcSum(jobs, comp, time = 0) {

FILE: greedy_scheduling/main.py
  class Job (line 3) | class Job:
    method __init__ (line 4) | def __init__(self, weight, length):
  class Solution (line 8) | class Solution:
    method minSum (line 9) | def minSum(self, jobs):
    method _calcSum (line 19) | def _calcSum(self, jobs, comp, time = 0, total = 0):
  function run (line 26) | def run(filename):

FILE: huffman/main.cpp
  type Tree (line 27) | struct Tree
    method Tree (line 32) | Tree(Weight weight, TreePtr left = nullptr, TreePtr right = nullptr) :
  type Tree (line 29) | struct Tree {
    method Tree (line 32) | Tree(Weight weight, TreePtr left = nullptr, TreePtr right = nullptr) :
  type Comp (line 38) | struct Comp {
  function TreePtr (line 44) | TreePtr encode(const Weights& A, Queue q = {}) {
  function TreePtr (line 61) | TreePtr encode(Weights& A, Queue first = {}, Queue second = {}) {
  function MinMax (line 88) | MinMax run(const string& filename) {
  function main (line 112) | int main() {

FILE: huffman/main.js
  class Tree (line 13) | class Tree {
    method constructor (line 14) | constructor(weight, left = null, right = null) {

FILE: huffman/main.py
  class Tree (line 11) | class Tree:
    method __init__ (line 12) | def __init__(self, weight, left = None, right = None):
    method __lt__ (line 16) | def __lt__(self, other):
  function encode (line 40) | def encode(A):
  function run (line 55) | def run(filename):

FILE: karatsuba/main.py
  function go (line 1) | def go(x, y):

FILE: knapsack/main.cpp
  function top_down (line 15) | int top_down(Pairs& A, int K, Map m = {}) {
  function bottom_up (line 31) | int bottom_up(Pairs& A, int K) {
  function bottom_up_memopt (line 48) | int bottom_up_memopt(Pairs& A, int K) {
  function run (line 65) | void run(const string& filename) {
  function main (line 78) | int main() {

FILE: knapsack/main.py
  function top_down (line 3) | def top_down(A, K):
  function bottom_up (line 16) | def bottom_up(A, K):
  function bottom_up_memopt (line 29) | def bottom_up_memopt(A, K):
  function run (line 42) | def run(filename):

FILE: kosaraju/main.cpp
  type Base (line 16) | namespace Base {
    class Solution (line 17) | class Solution {
      method Solution (line 21) | Solution(AdjList& adj, AdjList& rev) : adj{ adj }, rev{ rev } {}
  type Recursive (line 24) | namespace Recursive {
    type Solution (line 25) | struct Solution : public Base::Solution {
      method Solution (line 26) | Solution(AdjList& adj, AdjList& rev) : Base::Solution{ adj, rev } {}
      method Lists (line 27) | Lists kosaraju() {
      method List (line 46) | List topo_sort() {
  type Iterative (line 63) | namespace Iterative {
    type Solution (line 64) | struct Solution : public Base::Solution {
      method Solution (line 65) | Solution(AdjList& adj, AdjList& rev) : Base::Solution{ adj, rev } {}
      method Lists (line 66) | Lists kosaraju() {
      method List (line 87) | List topo_sort() {
  function run (line 108) | void run(string filename) {
  function main (line 123) | int main() {

FILE: kosaraju/main.js
  class BaseSolution (line 1) | class BaseSolution {
    method constructor (line 2) | constructor(adj, rev) {
  class RecursiveSolution (line 8) | class RecursiveSolution extends BaseSolution {
    method constructor (line 9) | constructor(adj, rev) {
    method topo_sort (line 12) | topo_sort() {
    method kosaraju (line 27) | kosaraju() {
  class IterativeSolution (line 48) | class IterativeSolution extends BaseSolution {
    method constructor (line 49) | constructor(adj, rev) {
    method topo_sort (line 52) | topo_sort() {
    method kosaraju (line 71) | kosaraju() {

FILE: kosaraju/main.py
  class BaseSolution (line 4) | class BaseSolution:
    method __init__ (line 5) | def __init__(self, adj, rev):
  class RecursiveSolution (line 9) | class RecursiveSolution(BaseSolution):
    method topo_sort (line 10) | def topo_sort(self):
    method kosaraju (line 24) | def kosaraju(self):
  class IterativeSolution (line 41) | class IterativeSolution(BaseSolution):
    method topo_sort (line 42) | def topo_sort(self):
    method kosaraju (line 58) | def kosaraju(self):
  function run (line 77) | def run(filename):

FILE: kruskal/main.cpp
  function kruskal (line 13) | int kruskal(Edges& E, int total = 0) {
  function run (line 38) | void run(const string& filename, Edges E = {}) {
  function main (line 48) | int main() {

FILE: kruskal/main.py
  function kruskal (line 3) | def kruskal(E, total = 0):
  function run (line 22) | def run(filename):

FILE: merge_sort/merge_sort.cpp
  class Solution (line 6) | class Solution {
    method VI (line 9) | VI mergesort(VI& A) {
    method VI (line 13) | VI go(VI&& A) {
    method VI (line 22) | VI merge(VI& A, VI& B, VI C = {}) {
  function main (line 33) | int main() {

FILE: merge_sort/merge_sort.py
  function sort (line 3) | def sort(A):

FILE: merge_sort_inversions/merge_sort_inversions.cpp
  class Solution (line 7) | class Solution {
    method Pair (line 12) | Pair merge(VL& A, VL& B, VL C = {}, long inv = 0) {
    method Pair (line 27) | Pair inversions(VL& A) {
  function run (line 42) | long run(string filename) {
  function main (line 51) | int main() {

FILE: merge_sort_inversions/merge_sort_inversions.py
  function sort (line 3) | def sort(A):
  function run (line 28) | def run(filename):

FILE: prim/main.cpp
  function getRandom (line 17) | int getRandom(int N) {
  function prim (line 23) | int prim(int N, AdjList& adj, Queue q = {}, Set seen = {}, int total = 0) {
  function run (line 40) | void run(const string& filename) {
  function main (line 53) | int main() {

FILE: prim/main.py
  function prim (line 4) | def prim(N, adj, total = 0):
  function run (line 20) | def run(filename):

FILE: quick_sort/main.cpp
  function partition (line 21) | int partition(VI& A, int L, int R, fun choosePivot) {
  function quicksort (line 37) | int quicksort(VI& A, int L, int R, fun choosePivot) {
  function run (line 45) | int run(string& filename, fun choosePivot) {
  function main (line 53) | int main() {

FILE: quick_sort/main.py
  function pivotLeft (line 1) | def pivotLeft(A, L, R): return L
  function pivotRight (line 2) | def pivotRight(A, L, R): return R
  function pivotMedian (line 3) | def pivotMedian(A, L, R):
  function partition (line 11) | def partition(A, L, R, choosePivot):
  function quicksort (line 24) | def quicksort(A, L, R, choosePivot):
  function run (line 30) | def run(filename, choosePivot):

FILE: rec_mat_mult/main.py
  function go (line 11) | def go(X, Y):
  function pretty_print (line 33) | def pretty_print(A, label=''):
  function main (line 46) | def main():

FILE: rselect/main.cpp
  function random (line 9) | int random(int L, int R) {
  function partition (line 16) | int partition(VI& A, int L, int R) {
  function rselect (line 30) | int rselect(VI& A, int i, int L, int R) {
  function run (line 41) | int run(string filename, int i, VI A = {}) {
  function main (line 48) | int main() {

FILE: rselect/main.py
  function partition (line 4) | def partition(A, L, R):
  function rselect (line 17) | def rselect(A, i, L, R):
  function run (line 27) | def run(filename, i):

FILE: strassen/main.py
  function go (line 11) | def go(X, Y):
  function pretty_print (line 40) | def pretty_print(A, label=''):
  function main (line 53) | def main():

FILE: strassen/variants.py
  function go (line 19) | def go(X: np.ndarray, Y: np.ndarray, method: str = "strassen") -> np.nda...
  function pretty_print (line 142) | def pretty_print(A, label=''):
  function main (line 153) | def main():

FILE: topo_sort/main.cpp
  class Solution (line 17) | class Solution {
    method Solution (line 25) | Solution(AdjList& adj) : adj{ adj }, N{ int(adj.size()) } {
    method init (line 27) | void init(int start) {
    method string (line 32) | string topo_sort_bfs() {
    method string (line 37) | string topo_sort_dfs() {
    method bfs (line 43) | void bfs() {
    method dfs (line 60) | void dfs(char start) {
    method string (line 70) | string to_string() {
  function main (line 78) | int main() {

FILE: topo_sort/main.js
  class Solution (line 1) | class Solution {
    method constructor (line 2) | constructor(adj) {
    method init (line 6) | init(start) {
    method topo_sort_bfs (line 11) | topo_sort_bfs() {
    method topo_sort_dfs (line 16) | topo_sort_dfs() {
    method bfs (line 22) | bfs() {
    method dfs (line 41) | dfs(u) {
    method to_string (line 50) | to_string() {

FILE: topo_sort/main.py
  class Solution (line 3) | class Solution:
    method __init__ (line 4) | def __init__(self, adj):
    method init (line 10) | def init(self, start):
    method topo_sort_bfs (line 15) | def topo_sort_bfs(self):
    method topo_sort_dfs (line 20) | def topo_sort_dfs(self):
    method bfs (line 26) | def bfs(self):
    method dfs (line 41) | def dfs(self, u):
    method to_string (line 49) | def to_string(self):

FILE: traveling_salesman/main.cpp
  class Solution (line 16) | class Solution {
    method string (line 21) | string key(int u, int v) {
    method init (line 26) | void init(const string& input_file, string line = {}) {
    method go (line 47) | void go(int u, VI&& path, Set&& seen, int t = 0) {
    method Pair (line 63) | Pair run(const string& input_file) {
  function main (line 71) | int main() {

FILE: traveling_salesman/main.js
  class Solution (line 3) | class Solution {
    method init (line 5) | init(input_file) {
    method run (line 27) | run(input_file) {
    method go (line 33) | go(u, path, seen, t = 0) {

FILE: traveling_salesman/main.py
  class Solution (line 4) | class Solution():
    method init (line 5) | def init(self, input_file):
    method run (line 21) | def run(self, input_file):
    method go (line 27) | def go(self, u, path, seen, t = 0):

FILE: weighted_independent_set/main.cpp
  type TopDown (line 22) | namespace TopDown {
    function LL (line 23) | LL best(List& A, Map m = {}) {
  type BottomUp (line 37) | namespace BottomUp {
    function LL (line 38) | LL best(List& A, Map m = {}) {
  type BottomUpMemOpt (line 52) | namespace BottomUpMemOpt {
    function LL (line 53) | LL best(List& A) {
  function run (line 68) | void run(const string& filename) {
  function main (line 80) | int main() {

FILE: weighted_independent_set/main.py
  function top_down (line 13) | def top_down(A):
  function bottom_up (line 24) | def bottom_up(A):
  function bottom_up_memopt (line 35) | def bottom_up_memopt(A):
  function run (line 47) | def run(filename):