SYMBOL INDEX (571 symbols across 155 files)

FILE: Problem001/C++/solution_1.cpp
  function main (line 8) | int main(int argc, char* argv[])

FILE: Problem001/C/solution_1.c
  function sumlista (line 44) | int sumlista(int* lista, int lenght){
  function increase (line 53) | void increase(int **data, int *lenght){
  function exist (line 60) | int exist(int *lista, int lenght, int num){
  function main (line 69) | int main(void){

FILE: Problem001/C/solution_2.c
  function main (line 11) | int main()

FILE: Problem001/Go/solution_1.go
  function main (line 9) | func main() {

FILE: Problem001/Java/solution_1.java
  class Main (line 1) | public class Main
    method main (line 3) | public static void main(String[] args)

FILE: Problem001/Ruby/solution_1.rb
  function solve (line 3) | def solve

FILE: Problem001/Rust/solution_1.rs
  function sum_all_multiples (line 1) | fn sum_all_multiples(limit: i32) -> i32 {
  function main (line 13) | fn main() {

FILE: Problem002/C++/solution_1.cpp
  function main (line 8) | int main(int argc, char *argv[])

FILE: Problem002/C/solution_1.c
  type _fib (line 15) | typedef struct fib {
  function main (line 23) | int main(void) {
  function even (line 40) | int even(int value) {
  function _fib (line 44) | _fib fibonacci(int limit) {

FILE: Problem002/Go/solution_1.go
  function p2 (line 5) | func p2(n int) int {
  function main (line 18) | func main(){

FILE: Problem002/JavaScript/solution_1.js
  function sequence_generator (line 7) | function sequence_generator(n, filter){

FILE: Problem002/Python/solution_1.py
  function fib_generator (line 11) | def fib_generator(n):
  function solution (line 18) | def solution(n):

FILE: Problem002/Ruby/solution_1.rb
  function fib (line 3) | def fib(n)
  function solve (line 15) | def solve

FILE: Problem003/C++/solution_1.cpp
  function largestPrime (line 4) | long long int largestPrime(long long int num){
  function main (line 15) | int main(){

FILE: Problem003/Elixir/solution_1.exs
  class Prime (line 1) | defmodule Prime
    method solve (line 2) | def solve(num), do: solve(num, 2)

FILE: Problem003/Go/solution_1.go
  constant NUM (line 8) | NUM = 600851475143
  function main (line 12) | func main() {
  function isPrime (line 21) | func isPrime(n uint64) bool {

FILE: Problem003/PHP/solution_1.php
  function prime (line 3) | function prime($num)

FILE: Problem003/Python/solution_1.py
  function prime_gen (line 26) | def prime_gen(n):

FILE: Problem004/C/solution_1.c
  function main (line 3) | int main()

FILE: Problem004/Go/solution_1.go
  function main (line 9) | func main() {
  function reverse (line 26) | func reverse(s string) (result string) {

FILE: Problem004/JavaScript/solution_1.js
  function is_palindrome (line 3) | function is_palindrome(s){
  function find_max_palindrom (line 7) | function find_max_palindrom(){

FILE: Problem004/Ruby/solution_01.rb
  function palindrome (line 3) | def palindrome(n)
  function solve (line 7) | def solve

FILE: Problem005/C++/solution_1.cpp
  function main (line 3) | int main(int argc, char **argv)

FILE: Problem005/C/solution_1.c
  function main (line 5) | int main(void) {

FILE: Problem005/Elixir/solution_1.exs
  class Solution (line 1) | defmodule Solution
    method solve (line 2) | def solve(n) do
    method find_recur (line 7) | defp find_recur(n, dvs, inc_rate) do

FILE: Problem005/Elixir/solution_2.exs
  class Euler5 (line 3) | defmodule Euler5
    method solve (line 4) | def solve(n) do
    method lcm (line 8) | def lcm(x, y), do: div(x * y, gcd(x, y))
    method gcd (line 10) | def gcd(x, 0), do: x
    method gcd (line 11) | def gcd(x, y) do

FILE: Problem005/JavaScript/solution_1.js
  function smallest_multiple (line 3) | function smallest_multiple() {

FILE: Problem005/Python/solution_2.py
  function div20 (line 2) | def div20(num):

FILE: Problem005/go/solution_1.go
  function smallest_multiple (line 5) | func smallest_multiple(number int) int {
  function main (line 20) | func main() {

FILE: Problem006/C++/solution_1.cpp
  function main (line 19) | int main(int argc, char **argv)
  function sum_of_squares (line 32) | long int sum_of_squares()

FILE: Problem006/Ruby/solution_1.rb
  function solve (line 3) | def solve

FILE: Problem006/go/solution_1.go
  function sumOfSquare (line 5) | func sumOfSquare(max int) int {
  function squareOfSum (line 13) | func squareOfSum(max int) int {
  function main (line 18) | func main() {

FILE: Problem007/C++/solution_1.cpp
  function main (line 10) | int main(int argc, char **argv)
  function is_prime (line 35) | bool is_prime(int n)

FILE: Problem007/Elixir/solution_2.exs
  class Solution (line 1) | defmodule Solution
    method nth_prime (line 2) | def nth_prime(n) do
    method prime_sequence (line 9) | def prime_sequence do
    method prime? (line 22) | def prime?(x) do

FILE: Problem007/Elixir/solution_slow_1.exs
  class Problem007 (line 3) | defmodule Problem007
    method isPrime (line 5) | def isPrime(1), do: false
    method isPrime (line 6) | def isPrime(2), do: true
    method isPrime (line 7) | def isPrime(3), do: true
    method isPrime (line 8) | def isPrime(n), do: (2..(n - 1)) |> Enum.find(fn x -> rem(n, x) == 0 e...
    method prime10001 (line 10) | def prime10001           , do: prime10001(1, 0)
    method prime10001 (line 11) | defp prime10001(x, 10001), do: x + 1
    method prime10001 (line 12) | defp prime10001(x, prime), do: prime10001(x + 1, prime + (if isPrime x...

FILE: Problem007/Python/primes.py
  function primeGen (line 16) | def primeGen(n):
  function primeGenEff (line 32) | def primeGenEff(n):
  function sieve5 (line 53) | def sieve5(n):

FILE: Problem008/Python/solution_1.py
  function product (line 55) | def product(num): return reduce(lambda x, y: x * y, [int(digit) for digi...

FILE: Problem009/Python/solution_1.py
  function decompSum (line 25) | def decompSum(n):
  function pythagorean (line 35) | def pythagorean(a, b, c):
  function problem9 (line 39) | def problem9(n):

FILE: Problem009/Ruby/solution_1.rb
  function solve (line 3) | def solve

FILE: Problem010/C++/solution_1.cpp
  function main (line 10) | int main(int argc, char* argv[])
  function is_prime (line 36) | bool is_prime(unsigned int number)

FILE: Problem010/Python/primes.py
  function prime_gen (line 1) | def prime_gen(n):
  function prime_gen_eff (line 17) | def prime_gen_eff(n):
  function primes_list (line 36) | def primes_list(lim):
  function sieve5 (line 248) | def sieve5(n):

FILE: Problem011/C++/solution_1.cpp
  function main (line 3) | int main()

FILE: Problem011/Elixir/solution_1.exs
  class GridProduct (line 22) | defmodule GridProduct
    method search_grid (line 23) | def search_grid(grid) do
    method find_val (line 43) | def find_val(horiz,diag,inner,outer,final) do
    method find_product_h (line 57) | def find_product_h(grid,col,row) do
    method find_product_d (line 63) | def find_product_d(grid,col,row) do
    method coord_vals (line 69) | def coord_vals(l,i) do
    method coord_val (line 73) | def coord_val(a,b,c) do
    method map_list_to_i (line 77) | def map_list_to_i(a) do
    method rev_transpose (line 81) | def rev_transpose(a,b) do

FILE: Problem011/Python/solution_1.py
  function arrowsSearch (line 36) | def arrowsSearch(matrix, n):
  function solution (line 59) | def solution(grid, arrow_length):

FILE: Problem012/C++/solution_1.cpp
  function LL (line 5) | LL countDivisors(LL n)
  function main (line 16) | int main()

FILE: Problem012/Elixir/solution_1.exs
  class Euler12 (line 3) | defmodule Euler12
    method solve (line 4) | def solve do
    method count_divisors (line 12) | def count_divisors(n) do

FILE: Problem012/JavaScript/solution_1.js
  function checkPrime (line 3) | function checkPrime(input, list) {
  function getNumOfDivisor (line 9) | function getNumOfDivisor(input) {
  function getTriangleNumber (line 44) | function getTriangleNumber() {

FILE: Problem012/Python/solution_1.py
  function trianglenums (line 37) | def trianglenums():
  function factoring (line 42) | def factoring(n):
  function divisors (line 53) | def divisors(n):
  function factors (line 68) | def factors(n):

FILE: Problem012/Python/solution_2.py
  function divisors (line 6) | def divisors(x):
  function diviTri (line 26) | def diviTri(n):

FILE: Problem012/Python/solution_3.py
  function trianglenums (line 37) | def trianglenums():
  function divisors (line 42) | def divisors(n):

FILE: Problem013/Ruby/solution_1.rb
  function solve (line 104) | def solve

FILE: Problem014/Elixir/solution_1.exs
  class Euler14 (line 3) | defmodule Euler14
    method solve (line 4) | def solve() do
    method largest_collatz (line 8) | defp largest_collatz(1_000_000, {_size, current}), do: current
    method largest_collatz (line 9) | defp largest_collatz(n, {size, _current} = acc) do
    method collatz (line 19) | def collatz(n), do: collatz(n, 1)
    method collatz (line 21) | defp collatz(1, acc), do: acc
    method collatz (line 22) | defp collatz(n, acc) do

FILE: Problem014/Python/solution_slow_1.py
  function sequence (line 33) | def sequence(n):
  function answer (line 44) | def answer():

FILE: Problem015/C/solution_1.c
  function main (line 3) | int main()

FILE: Problem015/Elixir/solution_1.exs
  class Fat (line 3) | defmodule Fat
    method fatorial (line 5) | def fatorial(1), do: 1
    method fatorial (line 6) | def fatorial(n), do: n * fatorial(n - 1)

FILE: Problem015/Python/solution_1.py
  function pascal (line 25) | def pascal(n):
  function solution (line 41) | def solution():

FILE: Problem015/Ruby/solution_1.rb
  function solve (line 4) | def solve

FILE: Problem016/Ruby/solution_1.rb
  function solve (line 3) | def solve

FILE: Problem017/Elixir/solution_1.exs
  class Euler17 (line 3) | defmodule Euler17
    method solve (line 4) | def solve(n) do
    method num_to_str (line 12) | def num_to_str(1000), do: "onethousand"
    method num_to_str (line 14) | def num_to_str(n), do: num_to_str(Integer.digits(n), [])
    method num_to_str (line 17) | defp num_to_str([], acc) do
    method num_to_str (line 30) | defp num_to_str([x | xs] = digits, acc) do
    method ten_text (line 47) | defp ten_text([x | xs]) do
    method ten (line 71) | def ten(n) do
    method unit (line 77) | def unit(n) do

FILE: Problem017/Python/solution_1.py
  function parser (line 29) | def parser(string):
  function decomp (line 44) | def decomp(string):
  function clear (line 54) | def clear(num):
  function solution (line 58) | def solution():

FILE: Problem018/Elixir/solution_1.exs
  class MaximumPath (line 19) | defmodule MaximumPath
    method new_val (line 29) | def new_val(a,b,c), do: String.to_integer(Enum.at(b,c)) + Enum.max([St...

FILE: Problem018/Python/solution_1.py
  function int_triangle (line 21) | def int_triangle(data):
  function arrows_recursive (line 24) | def arrows_recursive(data, total = [], main = [], x = 0, y = 0):

FILE: Problem019/Elixir/solution_1.exs
  class Sundays (line 1) | defmodule Sundays
    method check_day_and_month (line 21) | def check_day_and_month(count,day,month,year) do
    method leap_year? (line 39) | def leap_year?(year) do

FILE: Problem019/Python/solution_1.py
  function howmanysundays (line 47) | def howmanysundays(days, day):
  function is_leap (line 53) | def is_leap(year):
  function solution (line 57) | def solution(first_day):

FILE: Problem020/JavaScript/solution_1.js
  function getReducedFactorial (line 3) | function getReducedFactorial() {

FILE: Problem020/Ruby/solution_1.rb
  function solve (line 4) | def solve

FILE: Problem021/Elixir/solution_1.exs
  class Euler21 (line 3) | defmodule Euler21
    method solve (line 4) | def solve do
    method d (line 10) | def d(1), do: 1
    method d (line 11) | def d(n) do
    method amicable (line 17) | def amicable(a) do
    method sum (line 23) | defp sum(x, y), do: x + y

FILE: Problem021/Python/solution_1.py
  function d (line 26) | def d(n):

FILE: Problem023/Python/solution_1.py
  function divisors (line 28) | def divisors(num):
  function abundant (line 32) | def abundant(num):

FILE: Problem024/C++/solution_1.cpp
  function main (line 4) | int main() {

FILE: Problem024/Python/solution_1.py
  function factorial (line 28) | def factorial(n):
  function problem24 (line 33) | def problem24(element):

FILE: Problem025/Python/solution_1.py
  function fib (line 3) | def fib(max_lenght):

FILE: Problem026/C++/solution_1.cpp
  function get_max_rec (line 8) | int get_max_rec(int n)
  function main (line 28) | int main(int argc, char *argv[])

FILE: Problem026/Python/solution_1.py
  function get_rec_cycle (line 62) | def get_rec_cycle(n):
  function get_max_rec (line 82) | def get_max_rec(limit):

FILE: Problem027/C/solution_1.c
  type Result (line 19) | typedef struct {
  function quadratic (line 26) | int quadratic(int n, int a, int b) {
  function is_prime (line 32) | int is_prime(int n) {
  function eval_func (line 48) | int eval_func(int a, int b){
  function get_result (line 65) | void get_result(Result *r) {
  function main (line 81) | int main(int argc, char *argv[]) {

FILE: Problem027/Go/solution_1.go
  constant limit (line 16) | limit    = 1000
  constant nThreads (line 17) | nThreads = 16
  type result (line 20) | type result struct
  function quadratic (line 33) | func quadratic(a, b int) func(int) int {
  function memo (line 42) | func memo(f func(int) bool) func(int) bool {
  function isPrime (line 54) | func isPrime(n int) bool {
  function evalFunc (line 70) | func evalFunc(f func(int) int) int {
  function worker (line 85) | func worker(split int) {
  function receiver (line 102) | func receiver() (a int, b int, nPrimes int) {
  function main (line 114) | func main() {

FILE: Problem027/Python/solution_1.py
  function memo (line 15) | def memo(fn):
  function quadratic (line 31) | def quadratic(a, b):
  function isprime (line 39) | def isprime(n):
  function eval_func (line 48) | def eval_func(func):
  function search (line 59) | def search(limit):
  function main (line 68) | def main():

FILE: Problem028/C/solution_1.c
  function main (line 3) | int main()

FILE: Problem030/Elixir/solution_1.exs
  class DigitPowers (line 1) | defmodule DigitPowers
    method digit_power? (line 8) | def digit_power?(n) do

FILE: Problem030/Ruby/solution_1.rb
  function sum_digits (line 1) | def sum_digits(value)

FILE: Problem031/C/solution_1.c
  function different_ways (line 21) | int different_ways(int money, int *coins, int n_coins) {
  function main (line 40) | int main(int argc, char **argv){

FILE: Problem031/Elixir/solution_1.exs
  class Coins (line 1) | defmodule Coins
    method count (line 2) | def count([],_,vals),  do: vals
    method ad (line 12) | def ad(a,b,c), do: Map.put(c,b,(Map.get(c,b) + Map.get(c,(b-a))))

FILE: Problem031/Python/solution_1.py
  function different_ways (line 13) | def different_ways(money, coins, summation=0):
  function main (line 26) | def main():

FILE: Problem033/Python/solution_1.py
  function mdc (line 12) | def mdc(a, b):
  class fraction (line 19) | class fraction(object):
    method __init__ (line 21) | def __init__(self, x, y):
    method __repr__ (line 26) | def __repr__(self):
    method __mul__ (line 29) | def __mul__(self, frac):
    method mfact (line 38) | def mfact(self):
    method cfact (line 48) | def cfact(self):
    method fact (line 52) | def fact(self):
    method mdc (line 56) | def mdc(self):
    method new (line 59) | def new(self, w, z):
    method get (line 66) | def get(self, num):
    method cross (line 70) | def cross(self):
    method nums (line 74) | def nums(self):
    method non_trivial (line 78) | def non_trivial(self):
    method curious (line 84) | def curious(self):
  function solution (line 88) | def solution():

FILE: Problem034/C/solution_1.c
  function main (line 3) | int main()

FILE: Problem034/Elixir/solution_1.exs
  class Factorial (line 1) | defmodule Factorial
  class DigitFactorials (line 8) | defmodule DigitFactorials
    method digit_factorial? (line 24) | def digit_factorial?(num,facts) do

FILE: Problem034/Python/solution_2.py
  function findsum (line 6) | def findsum(n):

FILE: Problem034/Ruby/solution_1.rb
  function fat (line 1) | def fat(n)
  function check (line 9) | def check(n)

FILE: Problem035/Python/solution_1.py
  function is_prime (line 10) | def is_prime(n):
  function circPrime (line 21) | def circPrime(n):

FILE: Problem036/Elixir/solution_1.exs
  class DoubleBase (line 1) | defmodule DoubleBase
    method palindrome (line 2) | def palindrome(lim) do
    method pal? (line 13) | def pal?(n) do

FILE: Problem036/Go/solution_1.go
  function isPalindrome (line 8) | func isPalindrome(s string) bool {
  function main (line 19) | func main() {

FILE: Problem036/Python/solution_1.py
  function isPal (line 10) | def isPal(n):
  function binDecPal (line 14) | def binDecPal(x):

FILE: Problem036/Ruby/solution_1.rb
  function binary (line 1) | def binary(value)
  function palindrome (line 5) | def palindrome(value)
  function double_base (line 9) | def double_base(value)

FILE: Problem037/C++/solution_1.cpp
  function sieve (line 7) | void sieve(){
  function test (line 17) | bool test(int t)
  function main (line 37) | int main()

FILE: Problem037/Python/solution_1.py
  function memo (line 12) | def memo(fn):
  class TruncatePrime (line 28) | class TruncatePrime(int):
    method __init__ (line 37) | def __init__(self, x):
    method __add__ (line 42) | def __add__(self, other):
    method left (line 46) | def left(self):
    method right (line 50) | def right(self):
    method self (line 54) | def self(self):
    method walk (line 57) | def walk(self, orientation):
    method is_prime (line 64) | def is_prime(self, x):
    method is_truncate (line 73) | def is_truncate(self):
  function search_truncate (line 80) | def search_truncate(until=11):

FILE: Problem038/Elixir/solution_1.exs
  class Pandigital (line 1) | defmodule Pandigital
    method pandigital? (line 28) | def pandigital?(n) do

FILE: Problem038/Python/solution_1.py
  class PanDigital (line 12) | class PanDigital(int):
    method map (line 17) | def map(self, x):
    method concat (line 20) | def concat(self, digits):
    method can_continue (line 24) | def can_continue(self):
    method count (line 28) | def count(self):
    method sorted (line 32) | def sorted(self):
    method ispandig (line 36) | def ispandig(self):
    method transform (line 39) | def transform(self):
    method value (line 49) | def value(self):

FILE: Problem039/C/solution_1.c
  function main (line 4) | int main() {

FILE: Problem039/Elixir/solution_1.exs
  class RightInteger (line 1) | defmodule RightInteger
    method ad (line 25) | def ad(a,b), do: Map.put(b,a,(Map.get(b,a) + 1))

FILE: Problem040/Elixir/solution_1.exs
  class Champernowne (line 1) | defmodule Champernowne
    method constant (line 2) | def constant(lim) do

FILE: Problem040/Python/solution_1.py
  function frac_series_generator (line 13) | def frac_series_generator():
  function search_digit_by_index (line 20) | def search_digit_by_index(indexes):
  function main (line 32) | def main():

FILE: Problem041/Python/solution_slow_1.py
  function isPrime (line 3) | def isPrime(n) :
  function checker (line 17) | def checker(a): #function to check if the number has zero in it or not
  function repeatCheck (line 23) | def repeatCheck(a): #function to check if there is any repeating digit o...

FILE: Problem042/Elixir/solution_1.exs
  class TriangleWords (line 30) | defmodule TriangleWords
    method words (line 31) | def words(file,a_z_key) do
    method parse (line 42) | def parse(body,a_z_key) do
    method find (line 53) | def find([],count,_), do: count
    method triangle_numbers (line 58) | def triangle_numbers(words) do
    method triangle? (line 63) | def triangle?(word,tri_nums,count) do

FILE: Problem042/Python/solution_1.py
  function memo (line 13) | def memo(fn):
  function load_words (line 27) | def load_words():
  function string_to_num (line 33) | def string_to_num(string):
  function triangles (line 38) | def triangles():
  function is_triangle (line 45) | def is_triangle(num):
  function solution (line 53) | def solution():

FILE: Problem044/Python/solution_1.py
  function pentagonal (line 28) | def pentagonal(n):
  function pentagonal_list (line 32) | def pentagonal_list(n):
  function solution (line 36) | def solution():

FILE: Problem044/Python/solution_2.py
  function int_sqrt (line 12) | def int_sqrt(n):
  function pentagonal_number (line 59) | def pentagonal_number(n):
  function is_pentagonal (line 63) | def is_pentagonal(n):
  function answer (line 83) | def answer():

FILE: Problem045/C/solution_1.c
  type Polynom (line 24) | typedef struct {
  function main (line 29) | int main(int argc, char *argv[]) {

FILE: Problem045/Elixir/solution_1.exs
  class PolygonNumbers (line 1) | defmodule PolygonNumbers
    method gen (line 15) | def gen(n),  do: n * ((n * 2) - 1)
    method pent? (line 16) | def pent?(n) do

FILE: Problem045/Go/solution_1.go
  type Polynom (line 14) | type Polynom struct
  function main (line 22) | func main() {

FILE: Problem045/Python/solution_1.py
  function quadratic (line 29) | def quadratic(a, b, c):
  function solution (line 33) | def solution():

FILE: Problem045/Ruby/solution_1.rb
  class Integer (line 1) | class Integer
    method is_pentagonal? (line 2) | def is_pentagonal? # Inverse of pentagonal function
    method generate_hexagonal (line 6) | def generate_hexagonal
  class TrianglePentagonHexagon (line 11) | class TrianglePentagonHexagon
    method initialize (line 13) | def initialize
    method find_pentagonal (line 17) | def find_pentagonal # All hexagonal are triagonal

FILE: Problem046/Python/solution_1.py
  function sieve5 (line 10) | def sieve5(n):  # from primes algorithms on problem10
  function goldbach (line 26) | def goldbach(odd, p):
  function solution (line 39) | def solution(heuristic_start=10000):

FILE: Problem046/Ruby/solution_1.rb
  class Goldbach (line 1) | class Goldbach
    method initialize (line 4) | def initialize(finish)
    method find_goldbach (line 10) | def find_goldbach
    method sieve_of_eratosthenes (line 14) | def sieve_of_eratosthenes
    method generate_composites (line 18) | def generate_composites
    method generate_squares (line 22) | def generate_squares
    method sum_primes_and_squares (line 26) | def sum_primes_and_squares

FILE: Problem047/Python/solution_1.py
  function solution (line 13) | def solution(q):

FILE: Problem048/C/solution_1.c
  function pow_mod (line 32) | uint64_t pow_mod(uint64_t x, uint64_t e, uint64_t mod) {
  function main (line 42) | int main(void) {

FILE: Problem048/Go/solution_1.go
  function powMod (line 12) | func powMod(a float64, b float64, mod float64) float64 {
  function main (line 22) | func main() {

FILE: Problem048/Ruby/solution_1.rb
  function solve (line 3) | def solve

FILE: Problem049/Python/solution_1.py
  class PrimePermutations (line 13) | class PrimePermutations(int):
    method __init__ (line 23) | def __init__(self, x, min_permutations=3):
    method permutations (line 28) | def permutations(self):
    method primes (line 32) | def primes(self):
    method is_candidate (line 36) | def is_candidate(self):
    method _zip (line 39) | def _zip(self, content):
    method had_some_sequence (line 43) | def had_some_sequence(self):
    method sequence (line 47) | def sequence(self):
    method max (line 51) | def max(self):
    method diff (line 55) | def diff(self):
    method concat (line 59) | def concat(self):
    method solution (line 63) | def solution(cls):

FILE: Problem049/Python/solution_2.py
  function isPrime (line 4) | def isPrime(n) :

FILE: Problem050/Python/solution_slow_1.py
  function sumOfPrimes (line 28) | def sumOfPrimes(primes):
  function main (line 44) | def main(n):

FILE: Problem052/Ruby/solution_1.rb
  class PermutationMultiples (line 1) | class PermutationMultiples
    method initialize (line 4) | def initialize(finish)
    method find_permutations (line 8) | def find_permutations # Chose arbitrary number range => only checks un...
    method six_time_permutation? (line 12) | def six_time_permutation?(num) # Only check if each proceeding multipl...

FILE: Problem054/Python/solution_1.py
  function calculate_rank (line 9) | def calculate_rank(hand):

FILE: Problem055/Python/solution_1.py
  function reverse (line 4) | def reverse(x):
  function Palindrome (line 7) | def Palindrome(x):
  function checkLyr (line 14) | def checkLyr(x):

FILE: Problem056/Ruby/solution_1.rb
  function solve (line 3) | def solve

FILE: Problem058/Python/solution_1.py
  function is_prime (line 3) | def is_prime(n):
  class Problem058 (line 12) | class Problem058(object):
    method __init__ (line 15) | def __init__(self):
    method _diag_primes (line 20) | def _diag_primes(self):
    method _record_next_diag_primes (line 27) | def _record_next_diag_primes(self):
    method _solve (line 32) | def _solve(self, ratio_limit):
    method solve (line 38) | def solve(cls):

FILE: Problem062/Python/solution_1.py
  function cubesGen (line 19) | def cubesGen(n, start=1):
  function getId (line 23) | def getId(n):
  function isPerm (line 27) | def isPerm(a, b):
  function cubeRoot (line 35) | def cubeRoot(n):
  function mostCube (line 39) | def mostCube(n):
  function lowerCube (line 44) | def lowerCube(n):
  function solution (line 52) | def solution(max):
  function solution_extern (line 64) | def solution_extern():

FILE: Problem063/C/solution_1.c
  function num_length (line 4) | int num_length (double n) {
  function main (line 12) | int main(int argc, char **argv) {

FILE: Problem063/Elixir/solution_1.exs
  class PowerfulDigits (line 1) | defmodule PowerfulDigits
    method greater_than_n? (line 31) | def greater_than_n?(num,n,count) do
    method same_len? (line 40) | def same_len?(n,exp), do: exp == round(:math.pow(n,exp)) |> to_string ...

FILE: Problem063/Go/solution_1.go
  function numLength (line 10) | func numLength(n float64) int {
  function main (line 18) | func main() {

FILE: Problem067/Elixir/solution_1.exs
  class MaximumPath (line 1) | defmodule MaximumPath
    method new_val (line 11) | def new_val(a,b,c), do: String.to_integer(Enum.at(b,c)) + Enum.max([St...
  class Triangle (line 14) | defmodule Triangle
    method input (line 15) | def input(file) do

FILE: Problem067/Python/solution_1.py
  function int_triangle (line 14) | def int_triangle(data):
  class Tree (line 18) | class Tree(object):
    method __init__ (line 20) | def __init__(self, data):
    method solution (line 27) | def solution(self):
    method calc_route (line 31) | def calc_route(self, route):
    method num (line 34) | def num(self, index):
    method search (line 37) | def search(self):
    method insert_route (line 43) | def insert_route(self, last):
    method decise (line 50) | def decise(self):

FILE: Problem069/Python/solution_1.py
  function is_prime (line 3) | def is_prime(n):
  function max_phi_ratio (line 11) | def max_phi_ratio(n):
  function solve_problem_069 (line 20) | def solve_problem_069():

FILE: Problem069/Python/solution_2.py
  function sieve (line 6) | def sieve():
  function phi (line 16) | def phi(n):

FILE: Problem070/Python/solution_1.py
  function _prime_sieve (line 4) | def _prime_sieve(start, limit):
  function _is_permutation (line 19) | def _is_permutation(x, y):
  function min_phi_ratio (line 22) | def min_phi_ratio(limit):
  function solve (line 40) | def solve():

FILE: Problem076/Elixir/solution_1.exs
  class Summations (line 1) | defmodule Summations
    method count (line 2) | def count([],_,vals),  do: vals
    method ad (line 12) | def ad(a,b,c), do: Map.put(c,b,(Map.get(c,b) + Map.get(c,(b-a))))

FILE: Problem080/Python/solution_1.py
  function solution (line 16) | def solution(limit):

FILE: Problem081/Python/solution_1.py
  function parse_grid (line 24) | def parse_grid(data):
  class Grid (line 28) | class Grid(object):
    method __init__ (line 30) | def __init__(self, data):
    method solution (line 37) | def solution(self):
    method calcroute (line 41) | def calcroute(self, route):
    method num (line 44) | def num(self, index):
    method search (line 48) | def search(self):
    method insert_route (line 56) | def insert_route(self, last):
    method decise (line 63) | def decise(self):
  function run_test (line 81) | def run_test():
  function solution (line 92) | def solution():

FILE: Problem085/Python/solution_1.py
  function solve (line 4) | def solve(limit):

FILE: Problem087/Python/solution_1.py
  function _prime_sieve (line 3) | def _prime_sieve(start, limit):
  function solve (line 22) | def solve(limit):

FILE: Problem089/Elixir/solution_1.exs
  class RomanNumerals (line 1) | defmodule RomanNumerals
    method convert (line 2) | def convert(file) do
    method trunc_nums (line 11) | def trunc_nums(file) do
    method diff (line 19) | def diff(replaced,original), do: original - replaced

FILE: Problem089/Python/solution_1.py
  function check_valid_roman (line 15) | def check_valid_roman(string: str) -> int:
  function parse_roman (line 39) | def parse_roman(string: str) -> int:
  function to_roman (line 55) | def to_roman(integer: int) -> str:
  function main (line 80) | def main():

FILE: Problem092/Python/solution_slow_1.py
  function sequence_end (line 31) | def sequence_end(n, finalnum):

FILE: Problem092/Python/solution_slow_2.py
  function sequence_end (line 19) | def sequence_end(start):

FILE: Problem104/Python/solution_1.py
  function _is_pandigital (line 9) | def _is_pandigital(elem):
  function _fermat_approximation (line 15) | def _fermat_approximation(n):
  function _n_digit_of_decimal (line 18) | def _n_digit_of_decimal(d):
  function solve (line 22) | def solve():

FILE: Problem112/Python/solution_1.py
  function bouncy (line 34) | def bouncy(num: int) -> bool:
  function bouncy_counter (line 49) | def bouncy_counter(threshold: float):
  function main (line 62) | def main():

FILE: Problem145/Python/solution_slow_1.py
  function sumreverse (line 30) | def sumreverse(num):
  function reversible (line 32) | def reversible(num):
  function gen_filtred (line 35) | def gen_filtred(n, start = 1): # n - potencia de 10

FILE: Problem301/Python/solution_1.py
  function nim (line 3) | def nim():

FILE: Problem357/Python/solution_slow_1.py
  function divisors (line 28) | def divisors(n):
  function hnum (line 35) | def hnum(n, d):
  class prime_divisors (line 39) | class prime_divisors(object):
    method __init__ (line 45) | def __init__(self, max_value):
    method sum (line 52) | def sum(self):
    method is_hell (line 55) | def is_hell(self, n):
    method next_prime (line 58) | def next_prime(self):
    method run_from_hell (line 74) | def run_from_hell(self):
  function main (line 93) | def main():

FILE: Problem439/Python/solution_slow_1.py
  function gd (line 24) | def gd(k):
  function d (line 30) | def d(k):
  function g (line 34) | def g(n):
  function s (line 40) | def s(n):

FILE: Problem473/Python/solution_slow_1.py
  function gen (line 27) | def gen(x, sign = 1, start = 0, reverse = False):
  function phi_index (line 38) | def phi_index(n, resto = 0, lista = []):
  function suf_phi (line 58) | def suf_phi(n, resto = 0, lista = []):
  function phibase (line 75) | def phibase(n):
  function calc (line 97) | def calc(index):
  function intphi (line 107) | def intphi(phinum):
  function gen_palindromic (line 121) | def gen_palindromic(n):
  function palindromic (line 124) | def palindromic(string):

FILE: Problem473/Python/solution_slow_2.py
  function phi_pre_gen (line 26) | def phi_pre_gen(n):
  function phi_suf_gen (line 37) | def phi_suf_gen(n, resto):
  function checkpal (line 46) | def checkpal(n):

FILE: Problem500/Python/solution_1.py
  function primes_list (line 14) | def primes_list(n):
  function smallest_integer (line 19) | def smallest_integer(k, modulus=None):

FILE: Problem501/Python/solution_slow_1.py
  function d (line 23) | def d(n):
  function f (line 26) | def f(n):
  function f_p (line 29) | def f_p(n):

FILE: stats.exs
  class Settings (line 1) | defmodule Settings
    method start_link (line 2) | def start_link do
    method initial_state (line 6) | defp initial_state do
    method get (line 17) | def get(key) do
    method set (line 21) | def set(key, value) do
  class CLI (line 26) | defmodule CLI
    method run (line 45) | def run do
    method process (line 50) | def process({[help: true], _, _}) do
    method process (line 54) | def process({parsed, _, _}) do
    method help (line 76) | defp help do
  class Producer (line 85) | defmodule Producer
    method start_link (line 88) | def start_link(languages, all_languages?) do
    method init (line 92) | def init(problems) do
    method pop (line 96) | def pop do
    method handle_call (line 100) | def handle_call(:pop, _from, [h | t]) do
    method handle_call (line 103) | def handle_call(:pop, _from, []) do
    method problems (line 107) | defp problems(languages, all_languages?) do
  class Manager (line 138) | defmodule Manager
    method start_link (line 141) | def start_link do
    method init (line 146) | def init(workers) do
    method start_workers (line 156) | def start_workers do
    method next (line 160) | def next do
    method finished (line 164) | def finished(id, solution, time) do
    method handle_cast (line 168) | def handle_cast(:start_workers, {workers, _} = state) do
    method handle_cast (line 172) | def handle_cast(:next, {[id | available], workers}) do
    method handle_cast (line 193) | def handle_cast({:finished, id, solution, time}, {available, workers}) do
    method span_workers (line 200) | defp span_workers(n) do
  class Worker (line 208) | defmodule Worker
    method start_link (line 211) | def start_link(id) do
    method init (line 215) | def init(id) do
    method run (line 219) | def run(worker, solution) do
    method handle_cast (line 223) | def handle_cast({:run, solution}, id) do
  class Runner (line 235) | defmodule Runner
    method run (line 318) | def run({problem, lang, file}) do
    method run (line 323) | defp run(:build, cmd, {problem, lang, file}) do
    method run (line 333) | defp run(:execute, cmd, {problem, lang, file}) do
    method separate_command_from_flags (line 347) | defp separate_command_from_flags(cmd) do
  class Consumer (line 352) | defmodule Consumer
    method start_link (line 355) | def start_link do
    method consume (line 359) | def consume({problem, language, file}, time) do
    method output (line 363) | def output do
    method handle_cast (line 367) | def handle_cast({problem, language, file, time}, state) do
    method handle_cast (line 372) | def handle_cast(:output, state) do
  class Zipper (line 443) | defmodule Zipper
    method zip_with (line 447) | def zip_with([a|as], [b|bs], f) do
  class Renderer (line 452) | defmodule Renderer
    method start_link (line 463) | def start_link(quiet?) do
    method init (line 473) | def init(labels) do
    method render (line 479) | def render do
    method set_label (line 483) | def set_label(id, label) do
    method delete_label (line 487) | def delete_label(id) do
    method stop (line 491) | def stop do
    method handle_info (line 495) | def handle_info(:timeout, state) do
    method handle_cast (line 500) | def handle_cast(:render, labels) do
    method handle_cast (line 506) | def handle_cast({:set_label, id, label}, labels) do
    method handle_cast (line 510) | def handle_cast({:delete_label, id}, labels) do
    method handle_cast (line 514) | def handle_cast(:stop, labels) do
    method render_labels (line 519) | defp render_labels(labels) do
  class RendererQuiet (line 541) | defmodule RendererQuiet
    method init (line 544) | def init(_) do
    method handle_cast (line 548) | def handle_cast(_, _) do
  class Spinner (line 553) | defmodule Spinner
    method cursor_up (line 558) | def cursor_up, do: cursor_up(1)
    method cursor_up (line 559) | def cursor_up(count) do
    method erase_lines (line 563) | def erase_lines(count) do

FILE: stats.py
  class TimeOutController (line 35) | class TimeOutController:
    class TimeOut (line 36) | class TimeOut(Exception):
    method __init__ (line 39) | def __init__(self, sec=SOLUTION_TIMEOUT_VALUE):
    method cancel (line 43) | def cancel(self):
    method raise_timeout (line 46) | def raise_timeout(self, a, n):
  class Checker (line 50) | class Checker(object):
    method __init__ (line 54) | def __init__(self, compiler, path):
    method check (line 59) | def check(self):
  class Execute (line 67) | class Execute(Checker):
    method enter_dir (line 71) | def enter_dir(self):
    method exit_dir (line 75) | def exit_dir(self):
    method execute (line 78) | def execute(self):
  class Build (line 97) | class Build(Checker):
    method compile (line 103) | def compile(self):
    method execute (line 108) | def execute(self):
  function _callback (line 253) | def _callback(option, opt_str, value, parser):
  function walk_problems (line 350) | def walk_problems(root="."):
  function read_hashfile (line 365) | def read_hashfile(fpath):
  function get_problem_hashes (line 370) | def get_problem_hashes():
  function digest_answer (line 389) | def digest_answer(answer):
  function search_language (line 394) | def search_language(query, languages):
  function split_problem_language (line 410) | def split_problem_language(path):
  function is_solution (line 425) | def is_solution(string):
  function parse_solutions (line 430) | def parse_solutions(problems):
  function load_dataframe (line 450) | def load_dataframe():
  function solutions_paths (line 469) | def solutions_paths(df, from_files=None):
  function count_solutions (line 499) | def count_solutions(df, solutions=True):
  function handle_files (line 519) | def handle_files(files):
  function spinner (line 543) | def spinner(control):
  function choose_builder (line 558) | def choose_builder(lang, fpath):
  function execute_builder (line 574) | def execute_builder(b):
  function build_result (line 588) | def build_result(df, ignore_errors=False, blame=False, only=()):
  function list_by_count (line 631) | def list_by_count(df):
  function blame_solutions (line 639) | def blame_solutions(df):
  function remove_problem (line 650) | def remove_problem(df):
  function build_per_language (line 656) | def build_per_language(df):
  function header (line 670) | def header(opts):
  function handle_graph (line 674) | def handle_graph(df, options):
  function handle_options (line 690) | def handle_options(options):
  function main (line 760) | def main():