Repository: hacktoon/1001 Branch: master Commit: 9117eea9389d Files: 202 Total size: 263.4 KB Directory structure: gitextract_g4n0chn_/ ├── README.md ├── algorithms/ │ ├── ai/ │ │ ├── Astar.py │ │ ├── hamming.py │ │ └── knn.py │ ├── bioinformatics/ │ │ ├── gc_skew_diagram.py │ │ ├── reverse_complement.py │ │ ├── traducao.py │ │ └── transcricao.py │ ├── color/ │ │ └── rgb-to-cmyk.py │ ├── combinatory/ │ │ └── derangement.py │ ├── crypto/ │ │ ├── cesar.py │ │ ├── rot13.py │ │ ├── rsa.py │ │ └── vigenere.py │ ├── data-structures/ │ │ ├── arraysum.py │ │ ├── heap.py │ │ └── stack.py │ ├── date/ │ │ └── leap-year.py │ ├── economics/ │ │ └── financiamento.py │ ├── geography/ │ │ └── haversine.py │ ├── graphs/ │ │ ├── BellmanFord.py │ │ ├── Dijkstra.py │ │ ├── EdmondsKarp.py │ │ └── FloydWarshall.py │ ├── math/ │ │ ├── algebra/ │ │ │ ├── bhaskara.py │ │ │ ├── dda.py │ │ │ ├── media-num.py │ │ │ ├── media.py │ │ │ └── permutation.py │ │ ├── bisection-method.py │ │ ├── linear-algebra/ │ │ │ └── matrix-transpose.py │ │ ├── luhn.py │ │ └── number-theory/ │ │ ├── bozofactoring.py │ │ ├── divisors.py │ │ ├── eratosthenes.py │ │ ├── euclid.py │ │ ├── fatorial.py │ │ ├── fibonacci-matrix-form.py │ │ ├── fibonacci.py │ │ ├── miller-rabin.py │ │ ├── newton_raphson_sqrt.py │ │ ├── perfectnumber.py │ │ ├── pow.py │ │ ├── powmod.py │ │ └── stirling.py │ ├── misc/ │ │ └── helloworld.py │ ├── optimization/ │ │ ├── inteval_scheduling.py │ │ └── knapsack.py │ ├── pattern-matching/ │ │ ├── AhoCorasick.py │ │ ├── hamming.py │ │ ├── kmp.py │ │ └── levenshtein.py │ ├── physics/ │ │ └── ballistic.py │ ├── search/ │ │ ├── binary-search.py │ │ └── linear-search.py │ ├── sequence/ │ │ └── token.py │ └── sorting/ │ ├── bozosort.py │ ├── bubblesort.py │ ├── dropsort.py │ ├── insertionsort.py │ ├── masochisticsort.py │ ├── mergesort.py │ ├── quicksort.py │ ├── selectionsort.py │ └── sleepsort.py ├── modelo.txt └── other-languages/ ├── ai/ │ ├── genealogicaltree/ │ │ └── genealogicaltree.pro │ ├── sokoban/ │ │ ├── alberta/ │ │ │ ├── screen.1 │ │ │ ├── screen.1.sol │ │ │ └── screen.31 │ │ ├── runtests.sh │ │ ├── sokoban.cpp │ │ └── sokobanonline/ │ │ └── classic/ │ │ └── thinkingrabbit/ │ │ └── Boxxle/ │ │ ├── sk01-01.in │ │ ├── sk01-01.out │ │ ├── sk01-01.sol │ │ ├── sk01-02.in │ │ ├── sk01-02.out │ │ ├── sk01-02.sol │ │ ├── sk01-03.in │ │ ├── sk01-03.out │ │ ├── sk01-03.sol │ │ ├── sk01-04.in │ │ ├── sk01-04.out │ │ ├── sk01-04.sol │ │ ├── sk01-05.in │ │ ├── sk01-05.out │ │ ├── sk01-05.sol │ │ ├── sk01-06.in │ │ ├── sk01-06.out │ │ ├── sk01-06.sol │ │ ├── sk01-07.in │ │ ├── sk01-07.sol │ │ ├── sk01-08.in │ │ ├── sk01-08.sol │ │ ├── sk01-09.in │ │ ├── sk01-09.sol │ │ ├── sk02-10.in │ │ └── sk02-10.sol │ └── sudoku/ │ ├── sudoku.cpp │ └── test_001.in ├── array/ │ ├── merge/ │ │ └── merge.rb │ └── partition/ │ └── partition.rb ├── bitwise/ │ ├── BitScanForwardDebruijn64.cs │ ├── HammingWeight64.cs │ ├── bsf-debruijn/ │ │ └── BitScanForwardDebruijn64.cs │ ├── dec2hex/ │ │ └── dec2hex.c │ ├── hamming-weight/ │ │ └── HammingWeight64.cs │ ├── operations/ │ │ └── operations.cpp │ └── swap_xor/ │ ├── swap_xor.c │ ├── swap_xor.cs │ └── swap_xor.php ├── date/ │ └── leap-year/ │ ├── leap-year.lisp │ ├── leap-year.php │ └── leap-year.rb ├── economics/ │ ├── financiamento/ │ │ ├── financiamento.cs │ │ ├── financiamento.lisp │ │ ├── financiamento.php │ │ └── financiamento.rb │ └── juros-compostos/ │ └── juros-compostos.lisp ├── geography/ │ └── haversine/ │ └── haversine.rb ├── graphs/ │ ├── dijkstra/ │ │ ├── dijkstra.cpp │ │ └── dijkstra.java │ ├── floyd-warshall/ │ │ └── floyd-warshall.cpp │ └── prim/ │ └── prim.java ├── lang/ │ └── nums2words.c ├── math/ │ ├── bhaskara/ │ │ ├── bhaskara.lisp │ │ ├── bhaskara.php │ │ └── bhaskara.rb │ ├── dda/ │ │ ├── dda.cpp │ │ ├── dda.cs │ │ ├── dda.java │ │ ├── dda.php │ │ └── dda.rb │ ├── determinant/ │ │ ├── determinant.cpp │ │ └── determinant.rb │ ├── divisors/ │ │ └── divisor.rb │ ├── eratostenes/ │ │ └── eratostenes.java │ ├── even/ │ │ └── even.c │ ├── fatorial/ │ │ ├── fatorial.cs │ │ ├── fatorial.lisp │ │ ├── fatorial.php │ │ └── fatorial.rb │ ├── fibonacci/ │ │ ├── fibonacci.c │ │ ├── fibonacci.clj │ │ ├── fibonacci.cs │ │ ├── fibonacci.java │ │ ├── fibonacci.lisp │ │ ├── fibonacci.lua │ │ ├── fibonacci.php │ │ └── fibonacci.rb │ ├── gauss/ │ │ └── sumgauss.cpp │ ├── geometric-mean/ │ │ └── geometric-mean.cpp │ ├── linear-system/ │ │ └── linear-system.c │ ├── lu-decomposition/ │ │ ├── lu-decomposition.cpp │ │ └── lu-decomposition.rb │ ├── matrix-transpose/ │ │ └── matrix-transpose.cpp │ ├── media/ │ │ ├── media.lisp │ │ ├── media.php │ │ └── media.rb │ ├── media-num/ │ │ ├── media-num.c │ │ └── media-num.rb │ ├── multiply-matrix/ │ │ └── multiply-matrix.cpp │ ├── n-root/ │ │ └── MetodosNumericos.java │ ├── perfect-numbers/ │ │ └── perfectnumber.rb │ ├── pow/ │ │ └── pow.c │ └── stirlings-approximation/ │ └── stirling.clj ├── number-theory/ │ ├── euclid/ │ │ ├── euclid.lisp │ │ └── euclid.rb │ ├── inverse/ │ │ └── inverse.c │ ├── modular-exponentiation/ │ │ └── modular-exponentiation.cpp │ ├── odd/ │ │ └── odd.c │ ├── odd-even/ │ │ └── odd-even.c │ └── sieve/ │ ├── sieve.cpp │ └── sieve.lisp ├── pattern-matching/ │ └── lcs/ │ └── lcs.rb ├── physics/ │ └── ballistic/ │ └── ballistic.lisp ├── puzzle/ │ ├── hanoi/ │ │ └── hanoi.cpp │ └── sudoku-validation/ │ └── sudoku-validation.cpp ├── search/ │ ├── binary-search/ │ │ └── BuscaBinaria.java │ ├── linear-search/ │ │ └── linear-search.rb │ └── simul-smaller-higher/ │ └── simul-smaller-higher.cpp ├── sequence/ │ └── token/ │ ├── token.php │ └── token.rb └── sorting/ ├── bozosort/ │ ├── bozosort.lisp │ ├── bozosort.php │ └── bozosort.rb ├── bubblesort/ │ ├── bubblesort.lisp │ └── bubblesort.php ├── fisher-yates/ │ └── fisher-yates.c ├── heapsort/ │ └── heapsort.c ├── insertionsort/ │ ├── insertionsort.cpp │ ├── insertionsort.php │ └── insertionsort.rb ├── mergesort/ │ ├── mergesort.c │ └── mergesort.rb ├── quicksort/ │ ├── quicksort.c │ ├── quicksort.php │ └── quicksort.rb ├── selectionsort/ │ ├── selectionsort.cpp │ └── selectionsort.php ├── shellsort/ │ └── shellsort.cpp └── stoogesort/ └── stoogesort.cpp ================================================ FILE CONTENTS ================================================ ================================================ FILE: README.md ================================================ # 1001 algoritmos para implementar antes de morrer Vamos reunir 1001 implementações de algoritmos em um livro digital interativo que servirá principalmente de aprendizado para quem colaborar e guia/referência para jovens aspirantes a programadores. Do Bozosort ao crivo de Eratóstenes, teremos de tudo! Os códigos devem estar de acordo com os requisitos abaixo: * Siga este modelo de arquivo: [https://github.com/karlisson/1001/blob/master/modelo.txt](https://github.com/karlisson/1001/blob/master/modelo.txt) * Ser em Python. Lembre-se, é para iniciantes. * O algoritmo deve ser abrangente e multi-plataforma, ou seja, coisas específicas demais como "código para ligar o led da placa XPTO" não serão aceitas. Exemplo: problemas clássicos da computação e exercícios em geral. * Navegue no repositório e veja os algoritmos já adicionados antes de submeter. * O código não pode depender de bibliotecas extras que precisam ser instaladas. * O código deve conter testes ou exemplos de uso para que possa ser avaliado rapidamente, e não pode ser muito extenso (i.e. verboso). * O patch deve consistir em apenas um arquivo, cujo nome deve seguir o formato nome-algoritmo.py, onde 'nome-algoritmo' é o nome abreviado, minúsculo e sem espaços ou acentos. ================================================ FILE: algorithms/ai/Astar.py ================================================ # -*- coding: utf-8 -*- """ Algoritmo A* Autores: Peter Hart, Nils Nilsson and Bertram Raphael Colaborador: Péricles Lopes Machado [gogo40] (pericles.raskolnikoff.gmail.com) Tipo: graphs Descrição: O Algoritmo A* é uma generalização do algoritmo de Dijkstra que permite acelerar a busca com uma heuristica que utiliza propriedades do grafo para estimar a distância para o destino. Este algoritmo é ideal quando aplicados em grades ou representações espaciais e em situações em que já conhecemos a posição do destino. Complexidade: O(|E| log |V|) Dificuldade: medio Referências: [1] http://en.wikipedia.org/wiki/A*_search_algorithm [2] http://falapericles.blogspot.com.br/2009/05/o-algoritmo.html """ """ Função para imprimir o caminho """ def imprime_caminho(pi, u): ux = u[0]; uy = u[1]; if pi[ux][uy] == None: print u; else: imprime_caminho(pi, pi[ux][uy]); print u; """ Função para 'renderizar' o jogador numa posição da grade """ def renderizar_grade(G, ux, uy): l = list(G[ux]); l[uy] = 'x'; G[ux] = "".join(l); for i in range(0, len(G)): print " ", G[i]; print "---------"; l = list(G[ux]); l[uy] = '.'; G[ux] = "".join(l); """ Função para 'renderizar' a trajetória percorrida """ def renderizar_caminho(pi, G, u): ux = u[0]; uy = u[1]; if pi[ux][uy] == None: renderizar_grade(G, ux, uy); else: renderizar_caminho(pi, G, pi[ux][uy]); renderizar_grade(G, ux, uy); from heapq import *; from math import *; """ Este algoritmo utiliza uma grade para realizar a busca. A origem é marcada com o símbolo 'x' e o destino é marcado com o simbolo '+'. """ G = [ "###..####################..####################..####################..####################..#################.", ".........*........#.#..........*........#.#...........*........#.#...........*........#.............*.......#..", "....#....#.##.#####.#......#....#.##.#####.#......#....#.##.#####.#......#....#.##.#####........#....#.##.###..", "#...#....#..#......*..#...#....#..#......*..#...#....#..#......*..#...#....#..#......*......#....#..#......*...", "#.####...#*##+.....*.##.####...#*##......*.##.####...#*##......*.##.####...#*##......*.##.####...#*##......*.#.", "#....#..##.........#.##....#..##.........#.##....#..##.........#.##....#..##.........#.##..................#.#.", "#....#...#.###.##..####....#...#.###.##..####....#...#.###.##..####....#...#.###.##..####........#.###.##..###.", "#....#.......#..#....##....#.......#..#....##....#.......#..#....##....#...............##............#..#....#.", "#....#.......#..#....##....#.......#..#....##....#.......#..#....##....#.............................#..#....#.", "###..#.##########.#######..#.##########.#######..#.##########.#######..#.##########.##.####..#.##########.####.", "#...##.....#....#.#.......##.....#....#.#..##...##.....#....#.#.......##.....#....#.#.......##.....#....#.#..#.", "#..........#.....................#.........##..........#.....................#.........##..........#.........#.", "###..#.....##############..#.....##############..#.x...##############..#.....#########.####..#.....######..###.", ".........*.....................*......................*........#.#...........*..........#...........*.......#..", "....#....#.##.#####.#......#....#.##.#####.#......#....#.##.#####.#......#....#.##.#####.#......#....#.##..##..", "#...#....#..#......*..#...#....#..#......*..#...#....#..#......*...........#..#......*..#...#....#..#......*...", "#.####...#*##......*.##.####...#*##......*.##.####...#*##......*.##.####...#*##......*.##.####...#*##......*.#.", "#....#..##.........#.##....#..##.........#.##....#..##.........#.##....#..##.........#.......#..##.........#.#.", "#....#...#.###.##..####....#...#.###.##..####....#...#.###.##..####....#...#.###.##..####....#...#.###.##..###.", "#....#.......#..#....##....#.......#..#....##....#.......#..#....##....#.......#..#....##............#..#....#.", "#....#.......#..#....##....#.......#..#....##....#.......#..#....##....#.......#..#....##....#.......#..#....#.", "###..#.##########.#######..#.##########.#######..#.##########.#######..#.##########.#######..#.##########.####.", "#...##.....#....#.#..##...##.....#....#.#..##...##.....#....#.#..##...##.....#....#.#..##...##.....#....#.#..#.", "#..........#.........##..........#.........##..........#.........##..........#.........##..........#.........#.", "###..#.....##############..#.....##############..#.....##############..#.....##############..#.....###########.", "..............................................................................................................."]; """ Localizando a posição do jogador ('x') e do destino ('+') e inicializa matriz com estimativa de distância D. """ D = []; pi = []; for x in range(0, len(G)): D += [[]]; pi += [[]]; for y in range(0, len(G[x])): D[x] += [None]; pi[x] += [None]; if G[x][y] == 'x': s = (x, y); l = list(G[x]); l[y] = '.'; G[x] = "".join(l); elif G[x][y] == '+': t = (x, y); """ Possibilidades de movimentação: ... .x. ... """ dx = [-1, -1, -1, 0, 0, 1, 1, 1]; dy = [-1, 0, 1, -1, 1, -1, 0, 1]; """ Heurística que estima a distancia para o destino: H(p, t) = sqrt((p.x - t.x)^2 + (p.y - t.y)^2) Nesse código utilizamos o quadrado da distância euclidiana como estimativa. """ def H(s, t): Dx = s[0] - t[0]; Dy = s[1] - t[1]; return sqrt(Dx * Dx + Dy * Dy); def dist(s, t): Dx = s[0] - t[0]; Dy = s[1] - t[1]; return sqrt(Dx * Dx + Dy * Dy); Q = []; D[s[0]][s[1]] = 0; heappush(Q, (0, s)); """ Enquanto a fila de prioridade não estiver vazia tente verificar se o topo da fila é melhor opção de rota para se chegar nos adjascentes. Como o topo já é o mínimo, então garante-se que D[u] já está minimizado no momento. """ while Q: p = heappop(Q)[1]; u = (p[0], p[1]); ux = u[0]; uy = u[1]; """ Como já chegamos no destino, podemos parar a busca """ if u == t: break; for i in range(0, len(dx)): vx = u[0] + dx[i]; vy = u[1] + dy[i]; v = (vx, vy); duv = dist(u, v); if vx > -1 and vx < len(G): if vy > -1 and vy < len(G[vx]): if (D[vx][vy] > D[ux][uy] + duv or D[vx][vy] == None) and G[vx][vy] != '#': D[vx][vy] = D[ux][uy] + duv; pi[vx][vy] = u; """ A única diferença entre o A* e o dijkstra é o modo como é ordenado a heap. No caso, ela utiliza a heurítica H que procura colocar no topo os pontos mais próximos do destino. """ heappush(Q, (D[vx][vy] + H(v, t), v)); if D[t[0]][t[1]] != None: print "A distância entre s e t é: ", D[t[0]][t[1]]; """ Descomente essa linha caso queira ver a sequencia de passos percorrido pelo jogador """ imprime_caminho(pi, t); """ Descomente essa linha se quiseres ver o caminho percorrido na grade """ #renderizar_caminho(pi, G, u); else: print "Não existe caminho entre s e t!" ================================================ FILE: algorithms/ai/hamming.py ================================================ # coding: utf-8 ''' Hamming Distance Autor: Hamming Colaborador: Adriano Melo Dayvid Victor Tipo: artificial-intelligence Descrição: Algorítmo para calcular a distância entre vetores com dados categóricos. Complexidade: O(n) - sendo n o tamanho do vetor Dificuldade: fácil Referências: ''' def hamming(a, b): return sum([hamming_i(ai, bi) for ai, bi in zip(a,b)]) def hamming_i(ai, bi): return (0 if ai == bi else 1) def knn(k, treino, padrao, distancia=lambda a,b: sum([(c-d)**2 for c,d in zip(a,b)])): k_nearest = sorted([[distancia(pe[:-1], padrao), pe[-1]] for pe in treino])[:k] return max(set([e[-1] for e in k_nearest]), key = [e[-1] for e in k_nearest].count) if __name__ == '__main__': train = [['gordo', 'baixo', 'devagar', 'golfista'], ['magro', 'alto', 'rapido', 'jogador de basquete'], ['magro', 'baixo','rapido', 'jogador de futebol'], ['gordo', 'alto', 'rapido', 'jogador de futebol americano'], ['medio', 'medio', 'rapido', 'jogador de tenis']] padrao = ['magro', 'medio', 'rapido'] print knn(1, train, padrao, distancia = hamming) ================================================ FILE: algorithms/ai/knn.py ================================================ # coding: utf-8 ''' K-Nearest Neighboor (k-NN) Autor: Belur V. Dasarathy Colaborador: Adriano Melo Dayvid Victor Tipo: artificial-intelligence Descrição: Algoritmo de aprendizagem baseado em instâncias. Uma matriz é dada ao algoritmo contendo vetores e as classes que eles pertencem, um vetor não classificado é a segunda entrada do algoritmo. A saída é a classe que o vetor não classificado pertence. Complexidade: O(n * m * k) = O(n) n: número de instâncias m: tamanho dos vetores k: K-primeiros vizinhos Dificuldade: medio Referências: Belur V. Dasarathy, ed (1991). Nearest Neighbor (NN) Norms: NN Pattern Classification Techniques. ISBN 0-8186-8930-7. ''' def knn(k, treino, padrao, distancia=lambda a,b: sum([(c-d)**2 for c,d in zip(a,b)])): k_nearest = sorted([[distancia(pe[:-1], padrao), pe[-1]] for pe in treino])[:k] return max(set([e[-1] for e in k_nearest]), key = [e[-1] for e in k_nearest].count) treino = [ [1,2,3,4,5,6,'classe 1'], [1,2,3,3,5,6,'classe 1'], [2,3,5,6,7,8,'classe 2'], [9,9,9,9,9,9,'classe 3'], [9,9,9,9,9,8,'classe 3'], [9,9,9,9,9,7,'classe 3']] print knn(1, treino, [2,3,4,6,7,8]) print knn(3, treino, [2,3,4,6,7,8]) print knn(6, treino, [2,3,4,6,7,8]) ================================================ FILE: algorithms/bioinformatics/gc_skew_diagram.py ================================================ # coding: utf-8 """ Skew Diagram Autor: Colaborador: Guido Luz Percú (guidopercu@gmail.com) Tipo: bioinformatics Descrição: Monta os pontos de um diagrama GC Skew, um diagrama que mostra a diferença entre G (guanina) e C (citosina) em um DNA. Complexidade: ? Dificuldade: facil Referências: https://en.wikipedia.org/wiki/GC_skew Licenca: MIT """ def gc_skew_diagram(genome): qtd_c = 0 qtd_g = 0 skew = [0] for base in genome: if base == 'C': qtd_c += 1 elif base == 'G': qtd_g += 1 skew.append(qtd_g - qtd_c) return skew print(gc_skew_diagram('ACCCCGTACTGGGGG')) ================================================ FILE: algorithms/bioinformatics/reverse_complement.py ================================================ # coding: utf-8 """ Reverse Complement Autor: Colaborador: Guido Luz Percú (guidopercu@gmail.com) Tipo: bioinformatics Descrição: Converte uma sequência de DNA em seu complemento, isto é, inverte a string e troca A por T, T por A, C por G e G por C. Complexidade: ? Dificuldade: facil Licenca: MIT """ def reverse_complement(genoma): dicionario = {"A": "T", "T": "A", "C": "G", "G": "C"} complemento_reverso = [dicionario[x] for x in genoma[::-1]] return "".join(complemento_reverso) print(reverse_complement('ATCG')) # CGAT ================================================ FILE: algorithms/bioinformatics/traducao.py ================================================ # coding: utf-8 """ Tradução Autor: Colaborador: Guido Luz Percú (guidopercu@gmail.com) Tipo: bioinformatics Descrição: Complexidade: ? Dificuldade: facil Referências: https://pt.wikipedia.org/wiki/Tradu%C3%A7%C3%A3o_%28gen%C3%A9tica%29 https://en.wikipedia.org/wiki/Genetic_code Licenca: MIT """ def traducao(rna): assert len(rna) % 3 == 0 resultado = '' codigo_genetico = { 'UUC': 'F', 'CUC': 'L', 'AUC': 'I', 'GUC': 'V', 'UUU': 'F', 'CUU': 'L', 'AUU': 'I', 'GUU': 'V', 'UUA': 'L', 'CUA': 'L', 'AUA': 'I', 'GUA': 'V', 'UUG': 'L', 'CUG': 'L', 'AUG': 'M', 'GUG': 'V', 'UCU': 'S', 'CCU': 'P', 'ACU': 'T', 'GCU': 'A', 'UCC': 'S', 'CCC': 'P', 'ACC': 'T', 'GCC': 'A', 'UCA': 'S', 'CCA': 'P', 'ACA': 'T', 'GCA': 'A', 'UCG': 'S', 'CCG': 'P', 'ACG': 'T', 'GCG': 'A', 'UAU': 'Y', 'CAU': 'H', 'AAU': 'N', 'GAU': 'D', 'UAC': 'Y', 'CAC': 'H', 'AAC': 'N', 'GAC': 'D', 'UAA': '', 'CAA': 'Q', 'AAA': 'K', 'GAA': 'E', 'UAG': '', 'CAG': 'Q', 'AAG': 'K', 'GAG': 'E', 'UGU': 'C', 'CGU': 'R', 'AGU': 'S', 'GGU': 'G', 'UGC': 'C', 'CGC': 'R', 'AGC': 'S', 'GGC': 'G', 'UGA': '', 'CGA': 'R', 'AGA': 'R', 'GGA': 'G', 'UGG': 'W', 'CGG': 'R', 'AGG': 'R', 'GGG': 'G', } for i in range(0, len(rna), 3): traducao = codigo_genetico[rna[i:i+3]] if traducao != '': resultado +=traducao return resultado print(traducao('ACGUUA')) ================================================ FILE: algorithms/bioinformatics/transcricao.py ================================================ # coding: utf-8 """ Transcrição Autor: Colaborador: Guido Luz Percú (guidopercu@gmail.com) Tipo: bioinformatics Descrição: Transcrição é o processo de formação do RNAm mensageiro a partir da cadeia-molde de DNA Complexidade: ? Dificuldade: facil Referências: https://pt.wikipedia.org/wiki/Transcri%C3%A7%C3%A3o_%28gen%C3%A9tica%29 Licenca: MIT """ def transcrever(dna): """ Transforma string DNA em string RNAm """ return dna.replace('T', 'U') print(transcrever('ACGT')) ================================================ FILE: algorithms/color/rgb-to-cmyk.py ================================================ # encoding: utf-8 ''' RGB to CMYK Autor: ? Colaborador: Aurélio A. Heckert Tipo: color Descrição: Converte uma cor definida em RGB para CMYK. RGB é um sistema aditivo de definição de cores, representa a mistura de luz. Suas componentes são (em ordem) vermelho, verde e azul. CMYK é um sistema subtrativo de definição de cores, representa a mistura de pigmentos. Suas componentes são (em ordem) ciano, magenta, amarelo e preto. O preto no CMYK deriva uma necessidade do uso prático, já que a mistura dos 3 pigmentos é custoso, não é realmente preto e a sobreposição de impressões tornaria o desalinhamento mais perceptível nos detalhes escuros. O algorítimo deste exemplo considera as componentes como valores flutuantes entre 0 e 1, onde 0 significa sem representação e 1 máxima representação. Sendo assim o branco seria (1,1,1) em RGB e (0,0,0,0) em CMYK, o vermelho intenso seria (1,0,0) em RGB e (0,1,1,0) em CMYK e o laranja seria (1,0.5,0) em RGB e (0,0.5,1,0) em CMYK. A representação das componentes em valores flutuantes entre 0 e 1 pode parecer estranho pelo nosso costume em ver cores definidas com 1 byte por unidade, mas essa representação é bastante útil em vários algorítimos para manipulação de cores e ainda viabiliza representações com maior profundidades de cores (mais de 1 byte por componente). Complexidade: O(1) DIficuldade: facil Referências: http://en.wikipedia.org/wiki/RGB http://en.wikipedia.org/wiki/CMYK ''' def rgb2cmyk( red, green, blue ): black = min( 1-red, 1-green, 1-blue ) nb = 1 - black # negative black if black == 1: cyan = 0 magenta = 0 yellow = 0 elif nb > 0: cyan = ( nb - red ) / nb magenta = ( nb - green ) / nb yellow = ( nb - blue ) / nb else: cyan = 1 - red magenta = 1 - green yellow = 1 - blue return "%.1f %.1f %.1f %.1f" % ( cyan, magenta, yellow, black ) print 'Preto:\t\t\t', rgb2cmyk( 0.0, 0.0, 0.0 ) print 'Cinza escuro:\t\t', rgb2cmyk( 0.3, 0.3, 0.3 ) print 'Cinza médio:\t\t', rgb2cmyk( 0.5, 0.5, 0.5 ) print 'Cinza claro:\t\t', rgb2cmyk( 0.7, 0.7, 0.7 ) print 'Branco:\t\t\t', rgb2cmyk( 1.0, 1.0, 1.0 ) print 'Vermelho vivo:\t\t', rgb2cmyk( 1.0, 0.0, 0.0 ) print 'Vermelho sangue:\t', rgb2cmyk( 0.7, 0.0, 0.0 ) print 'Laranja:\t\t', rgb2cmyk( 1.0, 0.5, 0.0 ) print 'Verde Musgo:\t\t', rgb2cmyk( 0.6, 0.7, 0.6 ) ================================================ FILE: algorithms/combinatory/derangement.py ================================================ #!usr/bin/python # encoding: utf-8 """ Desarranjo Autor: Pierre Raymond de Montmort Colaborador: Carlos Rodrigues c11a10r9l8o7s6f5e4l3i2x1@yahoo.com.br Tipo: math Descrição: Algoritmo que calcula permutação caótica Dificuldade: facil Complexidade: ? Referência: http://pt.wikipedia.org/wiki/Desarranjo """ from __future__ import division def fatorial(x): if x <= 1: return 1 else: return x * fatorial(x-1) n = 5 d = 0 for i in range(0, n): d = d + ((-1) ** i / fatorial(i)) print fatorial(n) * d ================================================ FILE: algorithms/crypto/cesar.py ================================================ #!/usr/bin/env python # -*- encoding: utf-8 -*- """ Cesar Cipher (Cifra de César) Autor: César Colaborador: Apu, Sigano, InFog, Paulo, Doug, ExHora Tipo: crypto Descrição: Este algoritmo implementa a Cifra de César Este algoritmo foi implementado em um Dojo do Grupo de Compartilhamento do Conhecimento Santos Dumont Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Cifra_de_C%C3%A9sar Licenca: GPL """ __authors__ = ( "Apu", "Sigano", "InFog", "Paulo", "Doug", "ExHora" ) import string class Cesar(object): def __init__(self): self.INICIO = 65 self.FIM = 90 self.ESPACO = 32 def crypt(self, entrada = "", chave = 0): saida = "" entrada = entrada.upper() for letra in entrada: valor = ord(letra) if (not valor == self.ESPACO): valor += chave if (valor > self.FIM): valor -= 26 saida += chr(valor) return saida def decrypt(self, entrada = "", chave = 0): saida = "" entrada = entrada.upper() for letra in entrada: valor = ord(letra) if (not valor == self.ESPACO): valor -= chave if (valor < self.INICIO): valor += 26 saida += chr(valor) return saida c = Cesar() print c.crypt("a ligeira raposa marrom saltou sobre o cachorro cansado", 3) print c.decrypt("D OLJHLUD UDSRVD PDUURP VDOWRX VREUH R FDFKRUUR FDQVDGR", 3) ================================================ FILE: algorithms/crypto/rot13.py ================================================ #!/usr/bin/env python3.1 """ ROT13 Autor: ? Colaborador: Fernando Medeiros Tipo: sequence Descrição: Implementação do algoritmo ROT-13, ou "Rotate By 13". É um procedimento simples mas eficaz para garantir que textos eletrônicos não sejam lidos por distração ou acidente. Util para proteger mensagens que talvez o leitor não queira ler. Exemplo, "spoilers" sobre determinado assunto em Fóruns ou listas de discussão. Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/ROT13 """ def rot13(text): alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' rotated = 'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm' r13 = "".maketrans(alpha, rotated) return text.translate(r13) #Exemplos de uso: print(rot13("Agora estou usando ROT-13!")) #Exibe a mensagem: Ntben rfgbh hfnaqb EBG-13! print(rot13("Ntben rfgbh hfnaqb EBG-13!")) #Exibe a mensagem: Agora estou usando ROT-13! #Note que a mesma função é usada para codificar e decodificar o texto. ================================================ FILE: algorithms/crypto/rsa.py ================================================ #!/usr/bin/python # -*- coding: iso-8859-1 -*- """ RSA Autor: Ron Rivest, Adi Shamir, e Leonard Adleman Colaborador: Juan Lopes Tipo: crypto Descrio: Implementao simples do algoritmo RSA. Este algoritmo se baseia na dificuldade computacional da fatorao de nmeros inteiros. A idia que a chave pblica e privada sejam baseadas na multiplicao de dois nmeros primos (geralmente grandes) e que a relao entre elas exija o conhecimento dos fatores dessa multiplicao. Complexidade: O(n) Dificuldade: medio Referncias: http://en.wikipedia.org/wiki/RSA_(algorithm) """ def gcd(a,b): if b==0: return (1, 0) q = a/b x,y = gcd(b, a-q*b) return (y, x-q*y) def inverse(a, b): x,y = gcd(a,b) return (x if x > 0 else x+b) def rsa(n, e, M): return map(lambda m: pow(m, e, n), M) p,q = 41, 47 #primos n,phi = p*q, (p-1)*(q-1) #mdulo and totiente e,d = 7, inverse(7,phi) #expoentes pblico e privado plain = (1,2,3,4,5,6,7,42) encrypted = rsa(n, e, plain) plain_again = rsa(n, d, encrypted) print 'Chave pblica:', (n,e) print 'Chave privada:', (n,d) print '---' print 'Mensagem original:', plain print 'Mensagem encriptada:', encrypted print 'Mensagem decriptada:', plain_again ================================================ FILE: algorithms/crypto/vigenere.py ================================================ #!usr/bin/python # encoding: utf-8 """ Vigenère cipher (Cifra de Vigenère) Autor: Giovan Battista Bellaso (1553) "La cifra del. Sig. Giovan Battista Bellaso" Foi erradamente atribuida a Blaise de Vigenère Colaborador: damor - dave-world (at) hotmail.com Tipo: Crypto Descrição: Este algoritmo implementa o metodo de criptografia "Cifra de Vigenère" "A cifra de Vigenère consiste no uso de várias cifras de César em sequência, com diferentes valores de deslocamento ditados por uma "palavra-chave"" - Wiki Complexidade: ? Dificuldade: facil Referências: (opcional) http://pt.wikipedia.org/wiki/Cifra_de_Vigen%C3%A8re Licenca:(opcional) GPL """ class Vigenere(object): def __init__(self): self.tabulaRecta = [ [ 0 for i in range(26) ] for j in range(26) ] # Construir a tabula recta (Grelha de Vigenere) for i in range(26): for j in range(26): ch = ord("A")+j+i if (ch>90): ch-=26 self.tabulaRecta[i][j] = chr(ch) def crypt(self, plaintext = "", chave= ""): self.newKey=chave while len(self.newKey) 0 else None) def push(self, value): self.V.append(value) self.bubble_up(self.count()) def pop(self): if self.count() == 0: return None value = self.V[1] self.V[1] = self.V[-1] self.V.pop() self.bubble_down(1) return value def pop_all(self): while self.count() > 0: yield self.pop() def bubble_up(self, n): while n != 1 and self.less(n, n/2): self.swap(n, n/2) n /= 2 def bubble_down(self, n): while self.less(n*2, n) or self.less(n*2+1, n): c = self.min(n*2, n*2+1) self.swap(n, c) n = c def less(self, a, b): if a>self.count(): return False if b>self.count(): return True return self.V[a]', list(BinaryHeap(V).pop_all()) ================================================ FILE: algorithms/data-structures/stack.py ================================================ """ Stack Autor: ? Colaborador: Guido Luz Percú (guidopercu@gmail.com) Tipo: data-structures Descrição: Implementação da estrutura de dados Stack, uma coleção de elementos com duas operações principais: push e pop. Também conhecida por LIFO (last in, first out). Complexidade: ? Dificuldade: facil Referências: (opcional) http://www.wikiwand.com/en/Stack_%28abstract_data_type%29 """ class Stack: def __init__(self): self._stack = [] def __len__(self): return len(self._stack) def __str__(self): return "{}".format(self._stack) def top(self): return self._stack[-1] def push(self, value): self._stack.append(value) def pop(self): self._stack.pop() if __name__ == "__main__": pilha = Stack() pilha.push(1) pilha.push(2) pilha.push(3) print(pilha) print(pilha.top()) print("Tamanho da pilha: {}".format(len(pilha))) pilha.pop() print(pilha) print("Tamanho da pilha: {}".format(len(pilha))) print(pilha.top()) ================================================ FILE: algorithms/date/leap-year.py ================================================ # -*- encoding: utf-8 -*- """ Bissexto Autor: ? Colaborador: Bruno Lara Tavares Tipo: date Descrição: Calcula os próximos anos bissextos Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Ano_bissexto#Calend.C3.A1rio_Gregoriano """ from datetime import datetime def anoBissexto(anos): anoAtual = datetime.now().year proximoAno = anoAtual + anos for ano in range(anoAtual,proximoAno): if ano % 4 == 0 and (ano % 100 or ano % 400 == 0): yield ano for ano in anoBissexto(100): print ano ================================================ FILE: algorithms/economics/financiamento.py ================================================ # -*- encoding: utf-8 -*- """ Financiamento Autor: ? Colaborador: Bruno Lara Tavares Tipo: ? Descrição: Calcula o valor das parcelas do financiamneto baseado no capital inicial e taxa de juros de acordo na função Price Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Tabela_price#C.C3.A1lculo """ def parcelas(investimento, juros, periodo): return (investimento*juros) / (1 - (1/(1+juros)**periodo)) print parcelas(1000, 0.03, 4) ================================================ FILE: algorithms/geography/haversine.py ================================================ # -*- encoding: utf-8 -*- """ Haversine Autor: ? Colaborador: Bruno Lara Tavares Tipo: geography Descrição: Calcula a distancia mais curta entre dois pontos com latitude e longitude na superficie da Terra usando a formula de haversine Complexidade: ? Dificuldade: medio Referências: http://en.wikipedia.org/wiki/Haversine_formula """ from __future__ import division import math def strTodegree(string): grau, minuto, segundo = [int(x) for x in string.split()] if(string.find("-") == -1): grau += (minuto/60) + (segundo/3600) else: grau -= (minuto/60) + (segundo/3600) return grau def haversin(theta): return math.sin(theta/2)**2 def distancia(latitude1, longitude1, latitude2, longitude2): Radius = 6371 #Terra deltaLatitude = math.radians(latitude2 - latitude1) deltaLongitude = math.radians(longitude2 - longitude1) h = haversin(deltaLatitude) + math.cos(math.radians(latitude1))*math.cos(math.radians(latitude2))*haversin(deltaLongitude) return 2*Radius*math.asin(math.sqrt(h)) print distancia(strTodegree("53 08 50"),strTodegree("-01 50 58"),strTodegree("52 12 16"),strTodegree("00 08 26")) ================================================ FILE: algorithms/graphs/BellmanFord.py ================================================ # -*- coding: utf-8 -*- """ Algoritmo de Bellman-Ford. Autor: Richard Bellman & Lester R. Ford Jr. (1958) Colaborador: Pedro Arthur Duarte (JEdi) pedroarthur.jedi@gmail.com Tipo: graph shortest path on directed graphs with negative weighted edges Descrição: O algoritmo de Bellman-Ford determina o caminho mais curto de origem única em grafos com arestas de pesos negativos. Para grafos sem arestas negativas, o algoritmo de Dijkstra apresenta melhor desempenho. Complexidade: O(V*E), onde 'V' é a cardinalidade o conjunto de vértices e 'E' a cardinalidade do conjunto de arestas. Dificuldade: media Referências: http://en.wikipedia.org/wiki/Bellman-Ford_algorithm Licença: GPLv3 """ from sys import maxint class NegativeWeightCycleError(Exception): pass class Vertex: ''' Abstração de vértice para a implementação através de lista de adjacência; estão inclusos atributos extras para a implementação do algoritmo ''' def __init__(self, label, distance, predecessors=None): self.label = label self.distance = distance self.predescessor = None def __repr__(self): return str(self.label) class Edge: ''' Abstração de aresta para a implementação através de lista de adjacência ''' def __init__(self, source, destination, weight): self.src = source self.dst = destination self.wht = weight class Graph: ''' Abstração de grafo para a implementação através de lista de adjacência. ''' def __init__(self, graph=None): ''' Caso seja passada uma matriz de adjacência, essa é transformada numa lista de adjacência. ''' self.vertex = { } self.edges = [ ] if graph == None: return for i in xrange(0, len(graph)): for j in xrange(0, len(graph)): if graph[i][j] == None: continue self.addEdge(i, j, graph[i][j]) def addEdge(self, source, destination, weight): if source not in self.vertex: self.vertex[source] = Vertex(source, maxint) if destination not in self.vertex: self.vertex[destination] = Vertex(destination, maxint) self.edges.append( Edge(self.vertex[source], self.vertex[destination], weight)) class BellmanFord: def __init__(self, g): self.graph = g def adjacencyMatrixShortestPath(self, source, destination): '''Implementação através de matriz de adjacência''' # Etapa de inicialização: todas as distâncias são definidas como # infinitas para que sejam então atualizadas durante a relaxação self.distances = [ maxint for s in self.graph ] self.distances[source] = 0 # Arranjo auxiliar para que possamos reconstruir o menor caminho self.predecessors = [ 0 for s in self.graph ] # Para cada v em V: for i in xrange(0, len(self.graph)): # Para cada e em E # Aqui, devido ao uso da matriz de adjacência, precisamos # utilizar dois laços "para" (for) de forma que possamos # percorrer todas as aresta for u in xrange(0, len(self.graph)): for v in xrange(0, len(self.graph)): if self.graph[u][v] == None: continue # Etapa de "relaxação" do grafo if self.distances[u] + self.graph[u][v] < self.distances[v]: self.distances[v] = self.distances[u] + self.graph[u][v] self.predecessors[v] = u # Verificação da existência de círculos negativos for u in xrange(0, len(self.graph)): for v in xrange(0, len(self.graph)): if self.graph[u][v] == None: continue if self.distances[u] + self.graph[u][v] < self.distances[v]: raise NegativeWeightCycleError # lista de saída; índice -1 indica o custo total do menor caminho output = [ self.distances[destination] ] # Reconstruindo o menor caminho através do predecessor do destino while True: output.insert(0, destination) if destination == source: break else: destination = self.predecessors[destination] # Crianças, não façam isso em casa. return output[:-1], output[-1] def adjacencytListShortestPath(self, source, destination): ''' Implementação através de lista de adjacência; Funcionalmente, o mesmo código acima. Porém, bem mais limpo e menos devorador de memória. Adequado para matrizes esparsas. ''' source, destination = (self.graph.vertex[source], self.graph.vertex[destination]) # A etapa de inicialização está parcialmente implícita no construtor # da classe Vertex. Assim, precisamos apenas atualizar o valor de # distância do nó origem. source.distance = 0 for _ in self.graph.vertex: for e in self.graph.edges: if e.src.distance + e.wht < e.dst.distance: e.dst.distance = e.src.distance + e.wht e.dst.predescessor = e.src for e in self.graph.edges: if e.src.distance + e.wht < e.dst.distance: raise NegativeWeightCycleError output = [ destination.distance ] while True: output.insert(0, destination) if destination == source: break else: destination = destination.predescessor return output[:-1], output[-1] ''' Matriz de adjacência; None pode ser utilizado para representar a inexistência de arestas entre dois vértices. ''' graph = [ [7, 6, 8, 3, 5, 3, 2, 7, 1, 2, ], [0, 5, 2, 9, 1, 6, 2, 9, 9, 7, ], [6, 8, 7, 5, 8, 5, 7, 9, 8, 2, ], [6, 9, 7, 5, 8, 9, 8, 6, 3, 4, ], [0, 4, 8, 1, 6, 5, 8, 0, 7, 9, ], [2, 3, 3, 9, 9, 0, 0, 3, 0, 4, ], [7, 8, 0, 7, 7, 2, 9, 6, 0, 8, ], [3, 3, 5, 4, 8, 8, 8, 4, 4, 0, ], [9, 7, 2, 5, 0, 5, 4, 9, 0, 3, ], [6, 1, 8, 6, 6, 6, 1, 6, 7, 9, ], ] # Calculando o menor caminho através da matriz print BellmanFord(graph).adjacencyMatrixShortestPath(0,9) # Calculando o menor caminho através da lista print BellmanFord(Graph(graph)).adjacencytListShortestPath(0,9) ================================================ FILE: algorithms/graphs/Dijkstra.py ================================================ # -*- coding: utf-8 -*- """ Algoritmo de Dijkstra (com lista de adjascencias) Autores: Edsger Dijkstra Colaborador: Péricles Lopes Machado (pericles.raskolnikoff@gmail.com) Tipo: graphs Descrição: O Algoritmo de Dijsktra é um algoritmo em grafos clássico que determina a menor distância de um determinado vértice para todos os outros. Nessa implementação utiliza-se uma heap Complexidade: O(|E| log |V|) Dificuldade: medio Referências: [1] http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm [2] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. ISBN 978-0-262-53305-8. Páginas 658-659. """ from heapq import *; """ Função para imprimir rota """ def imprime_rota(pi, u): if pi[u] != None: imprime_rota(pi, pi[u]); print " ", u; """ Lista de adjacência; Para cada nó 'u' é fornecida uma lista de pares (v, d), onde 'v' é um nó que está conectado a 'u' e 'd' é a distancia entre 'u' e 'v' """ G = [ [(1, 2), (3, 4), (5, 3), (8, 9)], [(2, 7), (4, 6), (7, 8)], [(4, 9), (7, 9)], [(1, 13), (4, 4), (6, 3), (2, 3)], [(1, 23), (7, 4), (5, 3), (8, 1), (4, 9)], [(3, 11), (4, 7), (8, 9)], [(5, 2), (3, 5), (4, 3), (5, 9)], [(1, 2), (7, 4), (5, 9), (6, 8)], [(7, 2), (2, 3), (1, 1), (3, 1)], ]; """ Origem s e destino t """ s = 1; t = 6; N = len(G); """ Estimativa de distancia inicial None representa o infinito e código pai usado para recuperar a rota """ D = []; pi = []; for i in range(0, N): D += [None]; pi += [None]; """ Priority queue utilizada para o acesso rápido a melhor estimativa """ Q = []; D[s] = 0; heappush(Q, (0, s)); """ Enquanto a fila de prioridade não estiver vazia tente verificar se o topo da fila é melhor opção de rota para se chegar nos adjascentes. Como o topo já é o mínimo, então garante-se que D[u] já está minimizado no momento. """ while Q: u = heappop(Q)[1]; for adj in G[u]: v = adj[0]; duv = adj[1]; if D[v] > D[u] + duv or D[v] == None: D[v] = D[u] + duv; pi[v] = u; heappush(Q, (D[v], v)); if D[t] != None: print "Distância(", s, ",", t, ") = ", D[t]; print "Rota:"; imprime_rota(pi, t); else: print "Não há rota entre os nós ", s, " e ", t; ================================================ FILE: algorithms/graphs/EdmondsKarp.py ================================================ # -*- coding: utf-8 -*- """ Algoritmo de Edmonds-Karp. Autor: Jack Edmonds & Richard Karp (1972) Colaborador: Pedro Arthur Duarte (JEdi) pedroarthur.jedi@gmail.com Tipo: graph Descrição: O Algoritmo de Edmonds-Karp é uma implementação do método de Ford-Fulkerson para o cálculo do fluxo máximo em uma rede de fluxos. Esse algoritmo é idêntico ao método de Ford-Fulkerson excetuando-se no critério que utiliza para a escolha do caminho aumentante: o caminho precisa ser o menor caminho que possibilita o aumento do fluxo. Complexidade: O(V*E²), onde 'V' é a cardinalidade o conjunto de vértices e 'E' a cardinalidade do conjunto de arestas. Dificuldade: alta (?) Referências: http://en.wikipedia.org/wiki/Edmonds Licença: GPLv3 """ # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # from sys import stdin; DIMACS = 0 WFLOW = 1 RAW = 2 IMPERATIVE = 0 FUNCTIONAL = 1 class EdmondsKarp: # Cria nova instância da classe. # Parâmetros: # c: matriz de fluxos (f[i,j] = c[i][j]) # s: vértice do qual se origina o fluxo; # t: vértice de destino do fluxo; def __init__(self, c, s, t): self.c = c self.s = s self.t = t # Matriz auxiliar dos fluxos self.f = [[0] * len(i) for i in c] #print c # Iterador para auxiliar na construção da resposta def __iter__(self): return self # Busca primeiro em largura: def next(self): q = [ self.s ] p = { self.s: [] } # Critério: capacidade(e) - fluxoatual(e) > 0 # Implementação imperativa (aquela que se encontra geralmente nos livros) if self.approach == IMPERATIVE: for u in q: for v in xrange(len(self.c)): if self.c[u][v] - self.f[u][v] > 0 and v not in p: p[v] = p[u] + [(u,v)] if v == self.t: return p[v] q.append(v) # Implementação por meio de diretivas funcionais. Bonito, mas impraticável # para grandes instâncias desse problema. else: fcond = (lambda x: x[0][1] - x[1] > 0 and x[0][0] not in p) for u in q: for v in map( lambda x: x[0][0], filter(fcond, zip(enumerate(self.c[u]), self.f[u]))): p[v] = p[u] + [(u,v)] if v == self.t: return p[v] q.append(v) raise StopIteration # Esse algoritmo também é capaz de determinar o corte mínimo. # Esse método faz isso :-) def MinCutVertex(self): q = [ self.s ] o = [ ] for u in q: for v in xrange(len(self.c)): if self.c[u][v] - self.f[u][v] > 0 and v not in o: o.append(v) q.append(v) return o # Retorna a matriz de fluxos def FlowEdges(self, outtype=RAW): # Retorna a própria matriz de fluxos if outtype == RAW: return self # seleciona apenas os vértices que possuem algum fluxo if outtype == WFLOW: q = [ self.s ] p = [] u = 0 fcond = for u in q: f = map( lambda x: x[0][0], filter( lambda x:x[1]>0 and (u,x[0][0],self.f[u][x[0][0]]) not in p, zip(enumerate(self.c[u]), self.f[u]) ) ) for v in f: p = p + [(u,v,self.f[u][v])] q.append(v) return p # retorna nada =p else: return [ ] # Implementação do algoritmo de Edmonds-Karp def MaxFlow(self, approach=IMPERATIVE): self.approach = approach # Enquanto houverem caminhos aumentantes, # selecione aquele de menor custo; for p in self: # Dentro desse caminho, encontre a aresta # que possuí menor capacidade de vazão: mf = min(map(lambda e: self.c[e[0]][e[1]] - self.f[e[0]][e[1]], p)) # Ajuste os valores da matriz de fluxo de # acordo com o vazão da aresta encontrada # no passo anterior for u,v in p: self.f[u][v] += mf self.f[v][u] -= mf # Retorna o fluxo máximo return sum(self.f[self.s]) ================================================ FILE: algorithms/graphs/FloydWarshall.py ================================================ # -*- coding: utf-8 -*- """ Algoritmo de Floyd-Warshall. Autor: Robert W. Floyd & Stephen Warshall (1962) Colaborador: Pedro Arthur Duarte (JEdi) pedroarthur.jedi@gmail.com Tipo: graph all-pairs shortest path in weighted graphs dynamic programming Descrição: O algoritmo de Floyd-Warshall computa os caminhos mais curtos entre todos os pares de um grafo valorado de pesos arbitrários. A formulação em programação dinâmica para esse problema consiste em determinar de forma bottom-up os menores caminhos para todos os vértices considerando que os caminhos intermediários consistem apenas de um subconjunto de vértices. Assim, $d_{ij}^{(k)}$ é menor caminho do vértice $i$ ao vértice $j$ tal que esse caminho consiste apenas de vértices intermediários em $k$. Assim, a seguinte formulação é empregada no algoritmo de Floyd-Warshall: $$ d_{ij}^{(k)} = min(d_{ij}^{(k)}, d_{ik}^{(k-1)} + d_{kj}^{(k-1)}) $$ Essa formulação assuma que $d_{ij} = 0$ se $i=j$, e $d_{ij}=\infty$ se não há uma aresta entre os vértices $i$ e $j$. Complexidade: Θ(V³), onde 'V' é a cardinalidade o conjunto de vértices. Dificuldade: média Referências: Cormen; Leiserson; Rivest; Stein. Introduction to Algorithms (2 ed). ISBN: 978-0262033848. https://secure.wikimedia.org/wikipedia/en/wiki/Floyd–Warshall_algorithm Licença: GPLv3 """ from sys import maxint as Infinity class NoSuchAPathError(Exception): pass class FloydWarshall: def __init__(self, matrix): self.matrix = [ ] self.paths = [ ] for r in matrix: self.matrix.append([ ]) self.paths.append([ ]) for c in r: self.matrix[-1].append(c) self.paths[-1].append(None) def shortestPaths(self): for k in xrange(0, len(self.matrix)): for i in xrange(0, len(self.matrix)): for j in xrange(0, len(self.matrix)): if self.matrix[i][k] + self.matrix[k][j] < self.matrix[i][j]: self.matrix[i][j] = self.matrix[i][k] + self.matrix[k][j] self.paths[i][j] = k return self def getItermediate(self, source, destination): if self.matrix[source][destination] == Infinity: raise NoSuchAPathError intermediate = self.paths[source][destination] if intermediate is None: return [ ] return (self.getItermediate(source, intermediate) + [ intermediate ] + self.getItermediate(intermediate, destination)) def getPath(self, source, destination): return ([ source ] + self.getItermediate(source, destination) + [ destination ]) graph = [ [0, 6, 8, 3, 5, 3, 2, 7, 1, 2, ], [0, 0, 2, 9, 1, 6, 2, 9, 9, 7, ], [6, 8, 0, 5, 8, 5, 7, 9, 8, 2, ], [6, 9, 7, 0, 8, 9, 8, 6, 3, 4, ], [0, 4, 8, 1, 0, 5, 8, 0, 7, 9, ], [2, 3, 3, 9, 9, 0, 0, 3, 0, 4, ], [7, 8, 0, 7, 7, 2, 0, 6, 0, 8, ], [3, 3, 5, 4, 8, 8, 8, 0, 4, 0, ], [9, 7, 2, 5, 0, 5, 4, 9, 0, 3, ], [6, 1, 8, 6, 6, 6, 1, 6, 7, 0, ], ] print FloydWarshall(graph).shortestPaths().getPath(1,9) ================================================ FILE: algorithms/math/algebra/bhaskara.py ================================================ # encoding: utf-8 """ Bhaskara Autor: Bhaskara Akaria [1] Colaborador: Karlisson Bezerra Tipo: math Descrição: Calcula as raízes de uma equação de segundo grau Complexidade: O(1) DIficuldade: facil Referências: [1] http://pt.wikipedia.org/wiki/Bhaskara_Akaria """ import math def bhaskara(a, b, c): delta = b ** 2 - 4 * a * c if delta < 0: return None else: raizes = [] m1 = math.sqrt(delta) r1 =(-b + m1) / (2 * a) raizes.append(r1) r2 =(-b - m1) / (2 * a) raizes.append(r2) return raizes print(bhaskara(1, -1, -2)) ================================================ FILE: algorithms/math/algebra/dda.py ================================================ ''' DDA (Digital Differential Analyzer) Autor: ? Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: DDA um algoritmo de interpolao linear entre dois pontos, inicial e final. Ele muito usado na rea de Computao Grfica para rasterizar linhas e polgonos. Complexidade: O(n) Dificuldade: facil Referncias: http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf http://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm) ''' import math def DDA(x1, y1, x2, y2): points = [] #Guardar os pontos criados na forma (x, y) if (math.fabs(x2 - x1) >= math.fabs(y2 - y1)): len = math.fabs(x2 - x1) else: len = math.fabs(y2 - y1) deltax = (x2 - x1) / len deltay = (y2 - y1) / len x = x1 + math.copysign(0.5, deltax) y = y1 + math.copysign(0.5, deltay) for i in range(int(len)) : points.append((math.floor(x), math.floor(y))) x += deltax y += deltay points.append((math.floor(x), math.floor(y))) return points if __name__ == "__main__" : print DDA(-1, -1, 12, 9) ================================================ FILE: algorithms/math/algebra/media-num.py ================================================ # -*- encoding: utf-8 -*- """ Media Numerica Autor: ? Colaborador: Bruno Lara Tavares Guilherme Carlos (@guiessence) Tipo: math Descrição: Calcula a média de numeros inseridos pelo usuário Complexidade: 0(1) Dificuldade: facil """ from __future__ import division def media(*args): sum = 0 for i in args: sum += i return sum / len(args) #Adicione a quantidade de numeros que for preciso print media(2,3,4,10) ================================================ FILE: algorithms/math/algebra/media.py ================================================ # encoding: utf-8 """ Cálculo da média ponderada Autor: ? Colaborador: Karlisson Bezerra Tipo: math Descrição: Calcula a média ponderada - é um algoritmo comum em qualquer curso de introdução à programação, que pode variar de acordo com os pesos. Complexidade: O(1) Dificuldade: facil """ import math def media(n1, n2, n3): p1, p2, p3 = 4, 5, 6 return (n1 * p1 + n2 * p2 + n3 * p3) / (p1 + p2 + p3) print media(7.0, 8.0, 10.0) ================================================ FILE: algorithms/math/algebra/permutation.py ================================================ # encoding: utf-8 """ Permutation Autor: Fabian Stedma Colaborador: Bruno Gabriel dos Santos (bruno.gsantos89@gmail.com) Tipo: math Descrição: Calcula o número de combinações distintas que são possíveis de serem formadas por um array numérico. Complexidade: O(n!) Dificuldade: medio Referências: [1] https://en.wikipedia.org/wiki/Permutation#Algorithms_to_generate_permutations """ def permutation(input_data, temp_data, position): if position == len(input_data): print ''.join(str(temp_data)) else: for i in xrange(len(input_data)): is_same = False for j in xrange(position): if temp_data[j] == input_data[i]: is_same = True if not is_same: if len(temp_data) <= i: temp_data.append(input_data[i]) else: temp_data[position] = input_data[i] permutation(input_data, temp_data, position+1) permutation([1,2,3], [], 0) ================================================ FILE: algorithms/math/bisection-method.py ================================================ # encoding: utf-8 """ Método da Bisseção Autor: ? Colaborador: Lucas Andrade (lucasfael@gmail.com) Tipo: math Descrição: Calcula a raiz aproximada de uma equação polinomial qualquer dentro de um intervalo até uma precisão desejada. Complexidade: O(log n) Dificuldade: facil Referências: http://www.im.ufrj.br/dmm/projeto/projetoc/precalculo/sala/conteudo/capitulos/cap114.html """ import math def root(function, x0, x1, precision=0.0001): x0 *= 1.0 x1 *= 1.0 while (math.fabs(x0-x1) > precision): fx0 = function(x0) fx1 = function(x1) if (fx0 * fx1) > 0: return if fx0 == 0: return x0 if fx1 == 0: return x1 x2 = (x0 + x1) / 2 fx2 = function(x2) if (fx0 * fx2) < 0: x1 = x2 else: x0 = x2 return x0 def funcao(x): return math.pow(x, 3)-(9 * x) + 3 x = root (funcao, 0, 1) print x ================================================ FILE: algorithms/math/linear-algebra/matrix-transpose.py ================================================ # coding: utf-8 ''' Transposição de matrizes Autor: ? Colaborador: Dayvid Victor (victor.dvro@gmail.com) Tipo: math Descrição: Calcula a matriz tranposta de uma matriz qualquer, ou seja, a matriz resultante da troca das linhas pelas colunas. Complexidade de tempo: O(m*n) Dificuldade: facil Referências: http://en.wikipedia.org/wiki/Transpose ''' def get_transpose(matrix): return [[c for c in [l[i] for l in matrix]] for i in range(len(matrix[0]))] if __name__ == '__main__': matrix = [[1,1,1],[2,2,2],[3,3,3],[4,4,4],[5,5,5]] print matrix print get_transpose(matrix) ================================================ FILE: algorithms/math/luhn.py ================================================ # coding: utf-8 ''' Algorítimo de Luhn Autor: Hans Peter Luhn Colaborador: Alberto Chvaicer Tipo: math Descrição: Algoritimo utilizado para calular o dígito verificador baseado no módulo de 10. Utilizado por cartões de crédito e número IMEI. Complexidade de tempo: O(n) Dificuldade: media Referências: https://en.wikipedia.org/wiki/Luhn_algorithm ''' def luhn_checksum(card_number): def digits_of(n): return [int(d) for d in str(n)] digits = digits_of(card_number) odd_digits = digits[-1::-2] even_digits = digits[-2::-2] checksum = 0 checksum += sum(odd_digits) for d in even_digits: checksum += sum(digits_of(d*2)) return checksum % 10 def calculate_luhn(partial_card_number): check_digit = luhn_checksum(int(partial_card_number) * 10) return check_digit if check_digit == 0 else 10 - check_digit print 'the check digit of 7992739871 is %d' % (calculate_luhn(7992739871)) # should be 3 ================================================ FILE: algorithms/math/number-theory/bozofactoring.py ================================================ # encoding: utf-8 """ Bozo factoring Autor: Ricardo Bittencourt Colaborador: Ricardo Bittencourt (bluepenguin@gmail.com) Tipo: number-theory Descrição: Calcula os fatores primos de um numero usando o pior algoritmo conhecido. Complexidade: O(n^n) Dificuldade: medio Referências: http://blog.ricbit.com/2010/07/o-algoritmo-mais-lento-do-oeste.html Licenca: GPL """ import itertools def factor(n): solutions = [] for f in itertools.product(range(1,1+n),repeat=n): if reduce(lambda x,y: x*y, f) == n: solutions.append(filter(lambda x:x>1, list(f))) solutions.sort(key=len, reverse=True) return solutions[0] print factor(6) ================================================ FILE: algorithms/math/number-theory/divisors.py ================================================ # * encoding: UTF-8 * """ Divisors Autor: ? Colaborador: ? Descricao: Mostra os divisores de um número Complexidade: O(n) Dificuldade: facil """ n = int(raw_input("Digite um numero: ")) for i in range(1, n+1): if not n % i: print i, ================================================ FILE: algorithms/math/number-theory/eratosthenes.py ================================================ # -*- encoding: utf-8 -*- """ Crivo de Eratóstenes Autor: Eratóstenes de Cirene Colaborador: Juan Lopes (me@juanlopes.net) Tipo: Exemplos: math Descrição: Gera array de primalidade de inteiros através de algoritmo com baixa complexidade. Complexidade: O(n loglogn) Dificuldade: Médio Referências: (opcional) http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes """ from math import sqrt def sieve(n): P = [True]*n P[0] = False P[1] = False for i in xrange(2, int(sqrt(n))): if P[i]: for j in xrange(i**2, n, i): P[j] = False return P def primes_up_to(n): for i, p in enumerate(sieve(n)): if p: yield i print 'Primos ate 20:' for i in primes_up_to(20): print i ================================================ FILE: algorithms/math/number-theory/euclid.py ================================================ # encoding: utf-8 """ Algoritmo de Euclides Autor: Euclides de Alexandria Colaborador: Liquen Tipo: number-theory Descrição: Algoritmo de Euclides em sua forma moderna. Computa o máximo divisor comum (MDC) entre dois números inteiros. Parte do princípio de que o MDC não muda se o menor número for subtraído do maior. [1] [2] Complexidade: O(n^2), onde n é o número de dígitos da entrada. [3] O número de passos é no máximo log(max(a, b) * sqrt(5)) / log(phi), onde phi = 1.618... é a proporção áurea. [3] Dificuldade: facil Referências: [1] http://en.wikipedia.org/wiki/Euclidean_algorithm [2] http://pt.wikipedia.org/wiki/Algoritmo_de_Euclides [3] http://mathworld.wolfram.com/EuclideanAlgorithm.html """ def euclides(a, b): while b != 0: a, b = b, a % b return a print(euclides(1071, 462)) ================================================ FILE: algorithms/math/number-theory/fatorial.py ================================================ # encoding: utf-8 """ Cálculo de fatorial Autor: ? Colaborador: Bruno Lara Tavares Tipo: math Descrição: Calcula o fatorial de um número Complexidade: ? Dificuldade: facil """ def fatorial(b): return 1 if b <= 1 else b*fatorial(b-1) print fatorial(6) ================================================ FILE: algorithms/math/number-theory/fibonacci-matrix-form.py ================================================ # coding: utf-8 """ * Sequência de Fibonacci * * Autor: * Antonio Ribeiro * Tipo: * math * Descrição: * Na matemática, os Números de Fibonacci são uma sequência definida como recursiva. * O algoritmo recursivo que define a série aplica-se, na prática, conforme a regra sugere: * começa-se a série com 0 e 1; a seguir, obtém-se o próximo número de Fibonacci somando-se * os dois anteriores e, assim, sucessiva e infinitamente. * * Esta implementação baseia-se na propriedade de dividir-para-conquistar aplicada à * potenciação de matrizes para acelerar o cálculo do número de fibonacci, reduzindo * a complexidade do algoritmo para O(lg n) * Complexidade: * O(lg n) * Dificuldade: * Médio * Referências: * http://assemblando.wordpress.com/2011/05/14/pela-uniao-dos-seus-poderes/ * """ matriz_semente = [[1,1],[1,0]] def pow_matriz(b,n): """Realiza a potenciação da matriz b pelo expoente n usando dividir-para-conquistar""" if n==1: return b if n%2: h = pow_matriz(b,(n-1)/2) return multi_matriz(multi_matriz(h,h),b) else: h = pow_matriz(b,n/2) return multi_matriz(h,h) def multi_matriz(ma,mb): "Realiza a multiplicação de duas matrizes 2x2" (a,b),(c,d) = ma (e,f),(g,h) = mb return [[a*e+b*g,a*f+b*h],[c*e+d*g,c*f+d*h]] def fibo(n): "Realiza (matriz_semente)^n e retorna o elemento da linha zero, coluna um" if n==0 or n==1: return n return pow_matriz(matriz_semente, n)[0][1] if __name__=='__main__': for i in range(100): print fibo(i) ================================================ FILE: algorithms/math/number-theory/fibonacci.py ================================================ # -*- encoding: utf-8 -*- """ * Sequência de Fibonacci * * Autor: * Felipe Djinn * Colaborador: * Bruno Lara Tavares * Dilan Nery * Tipo: * math * Descrição: * Na matemática, os Números de Fibonacci são uma sequência definida como recursiva. * O algoritmo recursivo que define a série aplica-se, na prática, conforme a regra sugere: * começa-se a série com 0 e 1; a seguir, obtém-se o próximo número de Fibonacci somando-se * os dois anteriores e, assim, sucessiva e infinitamente. * Complexidade: * O(n) * Referências: * http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci * """ def fibonacci(nesimo): c, n1, n2 = 0, 0, 1 while c < nesimo: n1, n2 = n2, n1 + n2 c += 1 return n2 for nesimo in range(100): print fibonacci(nesimo) ================================================ FILE: algorithms/math/number-theory/miller-rabin.py ================================================ # -*- encoding: utf-8 -*- """ Teste de primalidade de Miller-Rabin Autor: Gary L Miller e Michael O. Rabin Colaborador: Juan Lopes (me@juanlopes.net) Tipo: math Descrição: Teste probabilistico de primalidade. Prova-se que para valores até 4.759.123.141, basta testar com as 'testemunhas' 2, 7 e 61. Este teste é muito mais rápido do que testar através de 'trial division', principalmente para números grandes. Complexidade: ? Dificuldade: difícil Referências: (opcional) http://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test """ def witness(a, n): u,t= (n/2, 1) while(u%2==0): u,t = (u/2, t+1) prev = pow(a,u,n); for i in xrange(t): curr=(prev*prev)%n if curr==1 and prev!=1 and prev!=n-1: return True prev=curr return curr != 1 def is_prime(n): if n in (0, 1): return False if n in (2, 7, 61): return True if witness(2,n): return False if witness(7,n): return False if witness(61,n): return False return True print 'Primos ate 20:' for i in xrange(1, 20): if is_prime(i): print i print '2 147 483 647?', is_prime(2147483647) print '2 147 483 648?', is_prime(2147483648) ================================================ FILE: algorithms/math/number-theory/newton_raphson_sqrt.py ================================================ # -*- encoding: utf-8 -*- """ Cálculo da raíz quadrada através do método de Newton-Raphson Autor: Isaac Newton e Joseph Raphson Colaborador: Alysson Oliveira (lssn.oliveira@gmail.com) Tipo: math Descrição: Método interativo para estimar as raízes de funções e pode ser aplicado a para o cálculo de rais quadrada. Complexidade: ? Dificuldade: fácil Referências: (opcional) https://pt.wikipedia.org/wiki/M%C3%A9todo_de_Newton-Raphson https://courses.csail.mit.edu/6.006/fall11/rec/rec12_newton.pdf http://www.iaps.org.in/journal/index.php/journaliaps/article/view/161/146 Guttag, John V. Introduction to Computation and Programming Using \ Python. MIT Press. 2013. ISBN 978-0-262-52500-8 """ def newton_raphson_sqrt(n, precisao=0.001, debug=False): """ n: Valor que se deseja obter a raíz precisao: Valor de precisão (ex.: 0.01) debug: Quando True mostra os chutes até que a precisão seja satisfeita """ chute = 0.5 * n while abs(chute * chute - n) >= precisao: if debug: print(' Chute:', chute) chute = chute - (((chute**2) - n) / (2 * chute)) return chute # Testando a função for i in 49, 64: print('Calculando raíz de {}'.format(i)) print('Resultado: {}'.format(newton_raphson_sqrt(i))) print(35 * '=') for i in 81, 100: print('Calculando raíz de {}'.format(i)) print('Resultado: {}'.format(newton_raphson_sqrt(i, 0.01, True))) print(35 * '=') ================================================ FILE: algorithms/math/number-theory/perfectnumber.py ================================================ # encoding: utf-8 """ Números perfeitos Autor: ? Colaborador: Anna Cruz (anna.cruz@gmail.com) Tipo: math, number-theory Descrição: Esse algoritmo serve para verificar se um número é perfeito ou não. Números perfeitos são aqueles cuja soma dos divisores (exceto ele mesmo) é igual ao próprio número, como por exemplo 6, cujos divisores são 1, 2 e 3 e 1+2+3 = 6 Complexidade: ? Dificuldade: fácil Referências: http://en.wikipedia.org/wiki/Perfect_numbers """ def calc_perf(number): counter = 1 divisors = [] sumarize = 0 while counter <= number/2: if number%counter == 0: divisors.append(counter) counter += 1 for divisor in divisors: temp = divisor sumarize += divisor if sumarize == number: print "This is a perfect number" else: print "This is not a perfect number try again" calc_perf(8128) ================================================ FILE: algorithms/math/number-theory/pow.py ================================================ # coding: utf-8 ''' Exponenciação Autor: ? Colaborador: Dayvid Victor (victor.dvro@gmail.com) Tipo: math Descrição: calcula exponenciação Complexidade de tempo: O(log n) Dificuldade: fácil Referências: ? ''' def pow(x, n): if n < 0: return float(1) / float(pow(x, -n)) p = (pow(x, n/2) if n != 0 else 1) return (p * p if n % 2 == 0 else p * p * x) print [pow(2,n) for n in range(11)] print [pow(2,n) for n in range(-11,0)] ================================================ FILE: algorithms/math/number-theory/powmod.py ================================================ # coding: utf-8 ''' Exponenciação Modular Autor: ? Colaborador: Juan Lopes Tipo: math Descrição: Calcula exponenciação modular de inteiros em tempo logaritmico. Baseia-se no fato de que: (a*b)%n == ((a%n) * (b%n)) % n Complexidade de tempo: O(log n) Dificuldade: fácil Referências: ? ''' def pow(x, e, m): if e==0: return 1 p = pow(x,e/2,m)%m k = (1 if e%2==0 else x) return (p*p*k)%m for i in range(20): print '3 ^ %d mod 1000 = %d (%d)' % (i, pow(3, i, 1000), 3**i) ================================================ FILE: algorithms/math/number-theory/stirling.py ================================================ # -*- encoding: utf-8 -*- """ Fórmula de Stirling Autor: Pedro Menezes DiogoK Tipo: math Descrição: A Fórmula de Stirling estabelece uma aproximação assintótica para o fatorial de um número. Referências: http://pt.wikipedia.org/wiki/F%C3%B3rmula_de_Stirling """ from math import sqrt, pi, e, pow def stirling(n): return sqrt(2*pi*n) * pow(n/e, n) if __name__ == '__main__': for n in xrange(1, 10): print("fat %d ~ %f" %(n, stirling(n))) ================================================ FILE: algorithms/misc/helloworld.py ================================================ """ Helloworld Autor: ? Colaborador: Karlisson - contato@nerdson.com Tipo: misc Descrição: Imprime a string Hello world Complexidade: O(1) Dificuldade: facil """ print "Hello world" ================================================ FILE: algorithms/optimization/inteval_scheduling.py ================================================ # -*- coding: utf-8 -*- """ Algoritmo guloso de agendamento de intervalos Autor: Colaborador: Pedro Arthur Duarte (JEdi) pedroarthur.jedi@gmail.com Tipo: Interval Scheduling Greed Algorithms Optimization Descrição: Dado um conjunto de tarefas expressos como t = (s,e), onde 's' especifica o inicio da tarefa e 'e' o seu fim, determinar o subconjunto máximo de tarefas que não se sobrepõem. Uma das maneiras de determinar esse subconjunto consiste em selecionar gulosamente as tarefas com base no seu horário de término: as tarefas com término mais cedo que não se sobrepõem são selecionadas para formar o subconjunto de saída. Complexidade: O(n), para um conjunto de tarefas ordenadas; O(n) + O(g(n)), para um conjunto de tarefas não ordenadas, onde 'g' é uma função de ordenação. Dificuldade: Fácil Referências: Kleinberg, Jon; Tardos, Eva (2006). Algorithm Design. ISBN 0-321-29535-8 Licença: GPLv3 """ def intervalScheduling(tasks): # Cópia a lista de tarefas e a ordena. O método "sort" das listas Python # é local. Portanto, caso seja necessário a lista original, não devemos # chamá-lo sem antes cloná-la. tasks = tasks[:] tasks.sort() # A tarefa com termino mais cedo sempre é a primeira do subconjunto # de saída scheduling = [ tasks[0] ] # Agora, para todos os outros elementos da lista ordenada de tarefas, nós # verificamos se esse elemento é compatível com as tarefas já presentes # no subconjunto de saída. Para uma lista ordenada, essa operação é O(1) # pois necessita apenas acessar a última tarefa inserida. for t in tasks[1:]: # Se o momento de inicio da tarefa é maior ou igual ao fim da última # tarefa do subconjunto de saída, ela é compatível. if t.start >= scheduling[-1].end: # E, logo, nós a inserimos no subconjunto de saída scheduling.append(t) # Por último, retornamos a lista return scheduling # Conjunto de tarefas de exemplo # --- ---- -------- # ---- --- - --- ---- # ---- -- -- --- -- # ---- --- ---- --- class Task: ''' Abstração das tarefas ''' start = 0 end = 0 def __init__(self, start, end): self.start = start self.end = end def __repr__(self): return '''''' % (self.start, self.end) def __cmp__(self, o): if self.end < o.end: return -1 if self.end == o.end: if self.start < o.start: return -1 elif self.start > o. start: return 0 else: return 1 return 1 # Em formato de lista tasks = [ Task(40, 70), Task(80, 120), Task(130, 210), Task(30, 70), Task(80, 110), Task(120, 130), Task(140, 170), Task(180, 220), Task(40, 80), Task(100, 120), Task(130, 150), Task(160, 190), Task(200, 220), Task(50, 90), Task(100, 130), Task(140, 180), Task(190, 220) ] print intervalScheduling(tasks) ================================================ FILE: algorithms/optimization/knapsack.py ================================================ # -*- coding: utf-8 -*- """ Algoritmo da Mochila Autor: Colaborador: Pedro Arthur Duarte (JEdi) pedroarthur.jedi@gmail.com Tipo: 0-1 Knapsack Problem Unbounded Knapsack Dynamic Programming Descrição: Dado uma conjunto de itens $I$ onde cada item $i$ possui um peso $p_i$ e um benefício $b_i$ associado, e uma mochila de carga máxima $m$, maximizar o benefício provido por uma combinação de itens respeitando a carga máxima suportda pela mochila. Em outras, palavras, satisfazer ao seguinte problema de otimização: % \begin{itemize} \item[] Maximizar $$\sum_{i=1}^{n} b_i x_i$$ \item[] com a restrição $$\sum_{i=1}^{n} p_i x_i \le m$$ \end{itemize} % onde $x_i$ é no número de repetiçoes do item $i$. A versão mais simples do problema, com cada item repetindo-se no máximo uma vez, ou $x_i \le 1$, é conhecida como 0-1 Knapsack. Instâncias sem essa limitação são conhecidas como Unbounded Knapsack. % OBS: a descrição acima é melhor visualizada após processada pelo LaTeX. % Visite http://scribtex.com/ para um compilador on-line Complexidade: O(nm), pseudo-polinomial no tempo, onde 'n' é cardinalidade do conjunto de item e 'm' é a carga máxima da mochila. O(nm), pseudo-polinomial no espaço para o 0-1 Knapsack O(m), pseudo-polinomial no espaço para o Unbounded Knapsack Dificuldade: Média Referências: Robert Sdgewick. Algorithms in C. ISBN 0-201-51425-7 https://secure.wikimedia.org/wikipedia/en/wiki/Knapsack_problem Licença: GPLv3 """ class Item: def __init__(self, value, weight, label=None): self.value = value self.weight = weight if label == None: self.label = str((self.value, self.weight)) else: self.label = label def __repr__(self): return '' class Knapsack: def __init__(self, maxWeight, items=None): self.maxWeight = maxWeight self.items = items def zeroOne(self, items=None): ''' Essa instância do problema da mochila possuí subestrutura ótima. Logo, é passível de resolução através de programação dinâmica. A seguinte formulação nos permite resolver esse problema numa abordagem bottom-up: % obs: LaTex code \[ M[i,j] = \left\{ \begin{array}{l l} M[i-1,j] & \text{se } p_i < j \\ max(M[i-1,j], M[i,j-p_i] + b_i) & \text{se } p_i \ge j\\ \end{array} \right. \] % Onde $M$ é uma matriz $n \times m$, $n$ é cardinalidade do conjunto de itens e $m$ a capacidade máxima da mochila. ''' if not items: items = self.items M = [[ 0 ] * (self.maxWeight+1)] for i,item in enumerate(items, start=1): M.append([ 0 ] * (self.maxWeight+1)) for w in xrange(1, self.maxWeight+1): if item.weight <= w: if M[i-1][w] > M[i-1][w-item.weight] + item.value: M[i][w] = M[i-1][w] else: M[i][w] = M[i-1][w-item.weight] + item.value else: M[i][w] = M[i-1][w] ''' $M[n,m]$ nos informa o máximo benefício obtido. Porém, para recuperar a lista de itens escolhidos, Precisamos analisar a matriz $M$ mais a fundo. Caso o benefício da mochila com configuração $M[i,m]$ seja diferente do benefício da mochila com configuração $M[i-1,m]$, o item $i$ está entre os itens escolhidos. Assim, devemos continuar nossa busca na posição $M[i-1,m-p_i]$. Caso contrário, o item $i$ não está em nossa mochila e devemos continuar a busca na posição $M[i-1,m]$. O código abaixo o descrito acima. ''' i,m = len(items), self.maxWeight output = [ ] while m > 0: if M[i][m] != M[i-1][m]: output.append(items[i-1]) m = m - items[i-1].weight i = i - 1 return M[-1][-1], output def unbounded(self, items=None): ''' Essa instância do problema também possuí subestrutura ótima. Logo, também é passível de resolução através de programação dinâmica. A seguinte formulação nos permite resolver esse problema numa abordagem bottom-up: % obs: LaTex code $$ \displaystyle M[j] = max(M[j-1], ~\max_{\forall i \in I | p_i < j}(b_i + M[j-p_i])) $$ % Onde $M$ é uma arranjo de cardinalidade $m$ e $m$ é a capacidade máxima da mochila. ''' if not items: items = self.items M = [0] * (self.maxWeight+1) # Para que possamos recupera a lista de itens escolhidos, precisamos # de um arranjo auxiliar para armazenar a melhor escolha para a mochila # de tamanho 'j'. c = [None] * (self.maxWeight+1) for i,item in enumerate(items, start=1): for j in xrange(1, self.maxWeight+1): if item.weight <= j: if M[j] < M[j-item.weight] + item.value: M[j] = M[j-item.weight] + item.value c[j] = item ''' Conceitualmente, $c[m]$ sempre está na mochila. Agora, para recuperar o restante dos itens, pasta decrementar m pelo peso do do item na posição em questão ($m = m - p_{c[m]}$) ''' m = self.maxWeight output = [ ] while m > 0: output.append(c[m]) m = m - c[m].weight return M[-1], output items = [ Item(15,2), Item(5,1), Item(20,3), Item(60,2) ] k = Knapsack(6, items) print k.zeroOne() print k.unbounded() ================================================ FILE: algorithms/pattern-matching/AhoCorasick.py ================================================ # -*- coding: utf-8 -*- """ Algoritmo de Aho-Corasick. Autor: Alfred Aho and Margaret Corasick (1975) Colaborador: Pedro Arthur Duarte (JEdi) pedroarthur.jedi@gmail.com Tipo: multi pattern string matching finite automate-based Descrição: Dado um conjunto de padrões, esse algoritmo constrói uma máquina de estados finitos de forma que seja possível buscá-los no texto de entrada em tempo linearmente proporcional ao tamanho dessa última. Para isso, o algoritmo de Aho-Corasick utiliza uma estrutura de dados semelhante as Tries, porém com nós adicionais que evitam a necessidade de backtracking. Esse nós adicionais representam o maior prefixo comum presente entre os padrões. Complexidade: O(⅀m) de pré-processamento, onde "m" é o tamanho do padrão O(n) de busca, onde "n" é o tamanho do texto de entrada Dificuldade: média (?) Referências: https://en.wikipedia.org/wiki/Aho-Corasick_algorithm Licença: GPLv3 """ class AhoCoraski(dict): failTransition = None isTerminal = False def __init__(self, patternList=None, thenBuild=False): if patternList is not None: self.add(patternList) if thenBuild is True: self.build() def add(self, pattern): if isinstance(pattern, list): for w in pattern: self.add(w) return self currentState = self for c in pattern: if c not in currentState: currentState[c] = AhoCoraski() currentState = currentState[c] currentState.isTerminal = pattern return self def build(self): queue = [ self ] while len(queue) > 0: current = queue.pop(0) for transition, next in current.iteritems(): state = current.failTransition while state is not None and transition not in state: state = state.failTransition if state is not None: next.failTransition = state[transition] else: next.failTransition = self queue.append(next) return self def match(self, subject): output = [ ] current = self if isinstance(subject, list): for s in subject: output += self.match(s) return output for c in subject: if c in current: current = current[c] else: current = current.failTransition while current is not None and c not in current: current = current.failTransition if current is not None: current = current[c] else: current = self if current.isTerminal is not False: output.append(current.isTerminal) return output patternList = [ 'he', 'she', 'his', 'her', 'show', 'shall', 'hall', ] print AhoCoraski(patternList, True).match("This phrase shall match") ================================================ FILE: algorithms/pattern-matching/hamming.py ================================================ # coding: utf-8 """ Hamming Distance Autor: Richard Hamming Colaborador: Guido Luz Percú (guidopercu@gmail.com) Tipo: edit-distance Descrição: A distância de Hamming, é o número de posições em duas strings de mesmo tamanho onde os símbolos correspondentes são diferentes. Mede o mínimo número de substituições (ou o número de erros) necessárias para transformar uma string em outra. Complexidade: ? Dificuldade: facil Referências: https://pt.wikipedia.org/wiki/Dist%C3%A2ncia_de_Hamming http://www.caip.rutgers.edu/~bushnell/dsdwebsite/hamming.pdf Licenca: MIT """ def hamming_distance(s1, s2): assert len(s1) == len(s2) return sum(ch1 != ch2 for ch1, ch2 in zip(s1, s2)) print(hamming_distance('ACGT', 'AGCT')) ================================================ FILE: algorithms/pattern-matching/kmp.py ================================================ # -*- encoding: utf-8 -*- """ KMP (Knuth-Morris-Pratt) algorithm Autor: Donald Knuth, Vaughan Pratt and James H. Morris Colaborador: Juan Lopes (me@juanlopes.net) Tipo: pattern-matching Descrição: Encontra todas as instâncias de P em Q em tempo linear. Usa tabela de lookup inicializada por P. Complexidade: O(n+m) Dificuldade: Médio Referências: (opcional) http://en.wikipedia.org/wiki/KMP_algorithm """ def kmp_init(P): F = [0]*(len(P)+1) i, j= 1, 0; while i Tipo: physics Descrição: Informa a distância horizontal quem um projétil atingiu baseado na força aplicada, força da gravidade e ângulo da força. Complexidade: 0(1) Dificuldade: facil Referências: [1]http://www.algosobre.com.br/fisica/balistica-e-lancamento-de-projetil.html """ from math import pi, sin, cos, radians def simula_tiro(angle, forca, gravidade, startY): angleR = radians(angle) # As funções sin e cos trabalham com radianos time = 0 # tempo inicial do tiro # Define os vetores de força vertical e horizontal VetorVertical = sin(angleR) * forca VetorHorizontal = cos(angleR) * forca # Pow! Y = startY X = 0 while Y > 0: # Enquanto a bala não cair... X = VetorHorizontal * time # Distância atual em X (S = V * t) Y = startY + (VetorVertical * time) - (gravidade * (time**2)) # Distância atual em Y (S = S0 + V*t + (a * t^2)/2) time += 1 return angle, X, Y forca = float(raw_input("Qual será a força? ")) gravidade = float(raw_input("Qual será a força da gravidade? ")) startY = float(raw_input("Qual será a altura do canhão? ")) try: angle = float(raw_input("Qual será o ângulo? (Opcional) ")) dados = simula_tiro(angle, forca, gravidade, startY) resultado = "Ângulo = %i\n X = %.5f\n Y = %.5f\n\n" % (dados[0], dados[1], dados[2]) print resultado except: for angle in range(0,91): # Faz a simulação em todos os ângulos de 0 a 90 dados = simula_tiro(angle, forca, gravidade, startY) resultado = "\nÂngulo = %i\nX = %.5f\nY = %.5f\n" % (dados[0], dados[1], dados[2]) print resultado ================================================ FILE: algorithms/search/binary-search.py ================================================ # coding: utf-8 ''' Busca Binária Autor: Jon Bentley Colaborador: Dayvid Victor (victor.dvro@gmail.com) Tipo: search Descrição: Faz uma busca em um vetor ordenado, usando o recurso 'dividir para conquistar'. Ele compara o valor a ser buscado com o centro do vetor, se for menor, o mesmo procedimento é feito com o sub-vetor da esquerda, se for maior, com o sub-vetor da direita. Complexidade de tempo: O(log n) Dificuldade: fácil Referências: http://pt.wikipedia.org/wiki/Pesquisa_binária ''' def binary_search(value, l): if len(l) == 0: return None mid = len(l)/2 if value < l[mid]: return binary_search(value, l[:mid]) elif value > l[mid]: tmp = binary_search(value, l[(mid + 1):]) return (tmp is not None) and tmp + mid + 1 or None return mid l = [0,1,2,3,4,7] print binary_search(-1,l) print binary_search(0,l) print binary_search(1,l) print binary_search(2,l) print binary_search(3,l) print binary_search(4,l) print binary_search(5,l) print binary_search(6,l) print binary_search(7,l) print binary_search(8,l) print binary_search(9,l) ================================================ FILE: algorithms/search/linear-search.py ================================================ # encoding: utf-8 """ Linear Search Autor: ? Colaborador: Bruno Lara Tavares José Alberto O. Morais Filho (j.moraisg12@gmail.com) Tipo: search Descrição: Utiliza força bruta em um array para retornar a posição de um valor nesse array, ou retornar -1, se nada for encontrado. Complexidade: O(n) Dificuldade: fácil """ # Entrada: # array = vetor onde o valor será pesquisado # search = valor procurado # Saída: # a posição da primeira ocorrência do valor, ou -1, caso o valor não for encontrado def linear_search(array, search): for k,v in enumerate(array): if v == search: return k return -1 # Exemplos a = [1,5, 6, 3, 7,4] print linear_search(a, 6) print linear_search(a, 60) ================================================ FILE: algorithms/sequence/token.py ================================================ #!/usr/bin/env python # -*- coding: UTF-8 -*- """ Token Autor: ? Colaborador: Felipe Djinn Tipo: sequence Descrição: Gera um token aleatório Complexidade: ? Dificuldade: facil """ import random import string def token(length = 10): return ''.join(random.choice(string.letters) for i in xrange(length)) """ Examples """ print "Token com 10 caracteres (padrão): " + token() print "Token com 5 caracteres: " +token(5) print "Token com 15 caracteres " +token(15) ================================================ FILE: algorithms/sorting/bozosort.py ================================================ # encoding: utf-8 """ Bozosort Autor: Bozo Colaborador: Karlisson Bezerra Tipo: sorting Descrição: Embaralha um vetor indefinidamente, até que os números estejam em ordem. Complexidade: O(infinito) Dificuldade: facil Referências: http://nerdson.com/blog/libbozo-01/ http://pt.wikipedia.org/wiki/Bogosort """ from random import shuffle def is_sorted(seq): # We define an empty sequence to be sorted by default. if not seq: return True # Otherwise, the sequence is sorted if every element is less or equal # than the next one. last = seq[0] for element in seq: if last > element: return False last = element return True def bozosort(seq): while not is_sorted(seq): shuffle(seq) return seq print bozosort([2,4,9,1,0,-4,17,8,0,23,67,-1]) ================================================ FILE: algorithms/sorting/bubblesort.py ================================================ # encoding: utf-8 """ Bubblesort Autor: ? Tipo: sorting Descrição: Varre o vetor comparando cada um dos pares de números possíveis e trocando suas posições no vetor se necessário Complexidade: Pior caso: O(n²) Melhor caso: O(n²) Dificuldade: facil Referências: http://en.wikipedia.org/wiki/Bubble_sort """ def bubble(lst): for i, val1 in enumerate(lst): for j, val2 in enumerate(lst): if lst[i] < lst[j]: lst[i], lst[j] = lst[j], lst[i] return lst print bubble([6, -7, 1, 12, 9, 3, 5]) ================================================ FILE: algorithms/sorting/dropsort.py ================================================ #!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Nome do algoritmo Autor: David Morgan-Mar. Colaborador: Vinícius dos Santos Oliveira Tipo: sorting Descrição: Dropsort é um algoritmo de ordernação lossy (causa perdas de informações) rápido, one-pass (lê a entrada exatamente uma vez, em ordem) O dropsort itera sobre os elementos da lista e, quando encontra um elemento menor que o anterior, descarta-o. Complexidade: O(n) Dificuldade: facil Referências: http://www.dangermouse.net/esoteric/dropsort.html http://students.cs.ndsu.nodak.edu/~abrjacks/dropsort.php (otimizações) Licenca: MIT """ def dropsort(lst): i = 0 prev = None while i != len(lst): if prev > lst[i]: del lst[i] else: prev = lst[i] i += 1 return lst if __name__ == '__main__': if dropsort([]) != []: exit(1) if dropsort([1, 2, 5, 3, 4, 6]) != [1, 2, 5, 6]: exit(1) if dropsort([1, 2, 2, 4]) != [1, 2, 2, 4]: exit(1) if dropsort([2, 11, 9, 8, 5, 4, 10, 3, 6, 0, 7, 13, 1, 12]) != [2, 11, 13]: exit(1) ================================================ FILE: algorithms/sorting/insertionsort.py ================================================ #!/usr/bin/env python # encoding: utf-8 ''' Insertion Sort Autor: ? Tipo: sorting Descrição: Percorre uma lista da esquerda para direita e vai deixando os elementos mais a esquerda ordenados à medida que avança pela lista. Complexidade: Pior caso: O(n²) Melhor caso: O(n) Dificuldade: Facil Referencia: http://pt.wikipedia.org/wiki/Insertion_sort ''' def insertion_sort(L): for i in range(1, len(L)): elemento = L[i] j = i - 1 while j >= 0 and L[j] > elemento: L[j+1] = L[j] j -= 1 L[j+1] = elemento return L ================================================ FILE: algorithms/sorting/masochisticsort.py ================================================ #!/usr/bin/env python # coding: utf-8 """ Masochistic Sort Author: Dilan Nery Colaborador: Dilan Nery Tipo: Ordenação Descrição: Testa todas combinações possiveis de uma lista até encontrar a combinação em que a lista esteja ordenada Complexidade: ? Dificuldade: medio Licensa: LGPL """ def masoquist_sort(L): if len(L) == 1: yield L elif len(L) == 2: count = 0 while count < 2: L[0],L[1] = L[1],L[0] yield L count += 1 else: for i in range(len(L)): L_copy = L[:] key = L_copy.pop(i) invert = masoquist_sort(L_copy) for i in invert: yield [key] + i def is_sorted(L): flag = True for i in range(1,len(L)): if L[i-1] > L[i]: flag = False return flag if __name__ == '__main__': teste1 = masoquist_sort([2,4,1,5,4]) for t1 in teste1: if is_sorted(t1): print t1 break teste2 = masoquist_sort([2, 11, 9, 8, 5, 4, 10, 3, 6, 0, 7, 13, 1, 12]) for t2 in teste2: if is_sorted(t2): print t2 break ================================================ FILE: algorithms/sorting/mergesort.py ================================================ # coding: utf-8 """ Mergesort Autor: John von Neumann, em 1945 Colaborador: Adriano Melo (adriano@adrianomelo.com) Dayvid Victor (victor.dvro@gmail.com) Tipo: sorting Descrição: O algoritmo ordena um vetor dividindo-o pela metade e, depois de processar cada metade recursivamente, intercala as metades ordenadas. Complexidade: O (n*log(n)) Dificuldade: fácil Referências: ? """ def intercala (inicio, fim): result = [] i, j = 0, 0 while i < len(inicio) and j < len(fim): if inicio[i] < fim[j]: result.append(inicio[i]) i = i + 1 elif inicio[i] >= fim[j]: result.append(fim[j]) j = j + 1 result = result + inicio[i:] result = result + fim [j:] return result def mergesort(array): tamanho = len(array) if tamanho == 1: return array inicio = mergesort (array[0:tamanho/2]) fim = mergesort (array[tamanho/2:]) return intercala (inicio, fim) print mergesort ([2,8,-2,1,45,37,-463,24,50,80,4,3,7,4,55]) print mergesort ([8,7,3,4,5]) ================================================ FILE: algorithms/sorting/quicksort.py ================================================ # coding: utf-8 """ Quicksort Autor: C.A.R. Hoare Colaborador: Adriano Melo (adriano@adrianomelo.com) Juan Lopes (me@juanlopes.net) Tipo: sorting Descrição: Quicksort é um algorítmo de ordenação de vetores cuja estratégia é dividir para conquistar. Basicamente o algorítmo organiza os elementos dos vetores de forma que os menores estejam antes dos maiores. Esse passo é feito recursivamente até que a lista completa esteja ordenada. Complexidade: O(n log(n)) - Melhor caso e médio caso. O(n²) - Pior caso. Dificuldade: facil Referências: (opcional) http://pt.wikipedia.org/wiki/Quicksort """ from random import randint def quicksort(V): if len(V) <= 1: return V pivot = V[0] equal = [x for x in V if x == pivot] lesser = [x for x in V if x < pivot] greater = [x for x in V if x > pivot] return quicksort(lesser) + equal + quicksort(greater) print quicksort([i for i in xrange(30)]) # worst case print quicksort([3 for i in xrange(30)]) # best case print quicksort([randint(-100, 400) for i in xrange(30)]) # average case ================================================ FILE: algorithms/sorting/selectionsort.py ================================================ # encoding: utf-8 ''' Insertion Sort Autor: ? Colaborador: Bruno Coimbra Tipo: sorting Descrição: Percorre uma lista a procura do menor valor e inclui na posição correta. Complexidade: O(n²) Dificuldade: Facil Referencia: http://pt.wikipedia.org/wiki/Selection_sort ''' from random import randint def selectionsort(L): for i in range(0, len(L)): minor = L[i] minor_pos = i for j in range(i+1, len(L)): if L[j] < minor: minor = L[j] minor_pos = j L[i], L[minor_pos] = minor, L[i] return L A = [randint(1, 50) for i in range(30)] print A print selectionsort(A) ================================================ FILE: algorithms/sorting/sleepsort.py ================================================ # -*- coding: utf-8 -*- """ Sleepsort Autor: ? Colaborador: Saulo Andrade Almeida Tipo: sorting Descrição: Uma brincadeira sobre ordenacao numerica baseada em threads e sleep. O algoritimo dispara threads para cada numero que sera ordenado com o tempo de espera baseado no valor do numero, ou seja quanto maior o numero mais ele demora para acordar e ser reinserido na nova estrututa ordenada. Para utilizar o algoritimo basta executar o arquivo e uma lista padrao sera executado, ou informar um lista de valores separados por espacos. Ex: $ python sleepsort.py ou $ python sleepsort 4 7 3 9 8 1 2 Complexidade: ? Dificuldade: facil Referências: (opcional) Adaptado de http://dis.4chan.org/read/prog/1295544154 """ import sys, time, threading def sleepit(val): time.sleep(val/4.0) print val # se nao vier parametro, usa uma lista padrao if not sys.argv[1:] : values = [7,9,2,5,6,4,1,8,3] # se vier, usa a lisra informada else: values = sys.argv[1:] # loop que dispara as threads print "Ordenando a lista ", values [ threading.Thread(target=sleepit, args=[int(a)]).start() for a in values ] ================================================ FILE: modelo.txt ================================================ """ Nome do algoritmo Autor: Nome do autor do algoritmo ou ? caso nao saiba Colaborador: Seu nome e email Tipo: tipo do algoritmo (em ingles, minusculo, separado por hifen) Exemplos: math, number-theory, sorting Descrição: O que este algoritmo faz? Serve pra que? Tente explicar da melhor forma possivel, ja que este projeto tem como publico-alvo os iniciantes. Complexidade: O(n), O(n^2)... ou ?, caso nao saiba Dificuldade: facil, medio ou dificil Referências: (opcional) links de referencia, um por linha Licenca:(opcional) GPL, BSD... """ #codigo ================================================ FILE: other-languages/ai/genealogicaltree/genealogicaltree.pro ================================================ /* Árvore Genealógica Autor: ??? Colaborador: Filipe Saraiva (filip.saraiva@gmail.com) Tipo: ai Descrição: Implementação de uma árvore genealógica em Prolog. Teste do mecanismo de inferência da linguagem. Complexidade: ??? Dificuldade: médio Referências: [1] Palazzo, L. Introdução à Programação Prolog, Editora da Universidade Católica de Pelotas, Pelotas, 1997. */ /* * Este código serve para apresentar os rudimentos da inferência * lógica da linguagem Prolog. Nele, criamos uma árvore genealógica * e, a partir da base de dados ("fatos"), conseguiremos extrair * conhecimento não disponível anteriormente. */ /* * Fatos - Base de Dados */ pai(raimundo, ana). pai(raimundo, renata). pai(raimundo, lucio). pai(estevao, marcelo). pai(estevao, pamela). pai(henrique, filomena). mae(marcela, ana). mae(marcela, renata). mae(sofia, lucio). mae(clarisse, marcelo). mae(clarisse, pamela). mae(sofia, filomena). masculino(raimundo). masculino(estevao). masculino(henrique). masculino(lucio). masculino(marcelo). feminina(marcela). feminina(sofia). feminina(clarisse). feminina(ana). feminina(renata). feminina(pamela). feminina(filomena). /* * Predicados */ % Verifica quais pessoas tem o mesmo pai e a mesma mãe de uma % pessoa "X". Estas são "irmãos total". irmaostotal(X, Z) :- pai(Y, X), mae(K, X), pai(Y, Z), mae(K, Z). ================================================ FILE: other-languages/ai/sokoban/alberta/screen.1 ================================================ 11 19 ################### #####...########### #####o..########### #####..o########### ###..o.o.########## ###.#.##.########## #...#.##.#####..xx# #.o..o..........xx# #####.###.#I##..xx# #####.....######### ################### ================================================ FILE: other-languages/ai/sokoban/alberta/screen.1.sol ================================================ ================================================ FILE: other-languages/ai/sokoban/alberta/screen.31 ================================================ 16 18 ################## ###..############# ###..##..#...##### ##..o#.oIo...##### ##o..o..#.o.o#..## ##..o##.#o.o.....# #..#..#.#...ooo..# #.o....o..o##.#### #.o.o.#o#..#..#### ##..###..###o.#### ##..#xxxx.....#### #####xxxxxx####### ####xxxx########## ####xxx########### ####xxx########### ################## ================================================ FILE: other-languages/ai/sokoban/runtests.sh ================================================ echo "As saídas do programa são jogadas nos arquivos .sol" g++ -O2 -o sokoban sokoban.cpp echo "teste 1" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.sol echo "teste 2" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.sol echo "teste 3" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.sol echo "teste 4" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.sol echo "teste 5" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.sol return; echo "teste 6" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.sol echo "teste 7" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.sol echo "teste 8" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.sol echo "teste 9" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.sol echo "teste 10" ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.out diff sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.out sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.sol ================================================ FILE: other-languages/ai/sokoban/sokoban.cpp ================================================ /* # -*- coding: utf-8 -*- """ Algoritmo A* aplicado na resolução de um sokoban + representação de estados por meio de grafo de estados. Autores: Peter Hart, Nils Nilsson and Bertram Raphael Colaborador: Péricles Lopes Machado [gogo40] (pericles.raskolnikoff.gmail.com) Tipo: graphs Descrição: O Algoritmo A* é uma generalização do algoritmo de Dijkstra que permite acelerar a busca com uma heuristica que utiliza propriedades do grafo para estimar a distância para o destino. Este algoritmo é ideal quando aplicados em grades ou representações espaciais e em situações em que já conhecemos a posição do destino. O grafo de estados é uma representação importante que permite implementar mais facilmente AIs que buscam soluções ótimas pra puzzles. O sokoban é um problema NP difícil, então basicamente procura-se utilizar heurísticas que estimam a solução correta para acelarar as buscas. Este algoritmo realiza algumas podas para evitar expandir muito o grafo de estados. Obviamente, ele é muito simples ainda, já que há heurísticas bem mais sofisticadas disponíveis na literatura[4]. Complexidade: O(2^N) Dificuldade: Difícil Referências: [1] http://en.wikipedia.org/wiki/A*_search_algorithm [2] http://falapericles.blogspot.com.br/2009/05/o-algoritmo.html [3] http://falapericles.blogspot.com.br/2009/05/grafo-de-estados-e-suas-aplicacoes.html [4] http://webdocs.cs.ualberta.ca/~games/Sokoban/ """ */ /* Para testar esse programa, por favor utilize o script runtests.sh. Como ele é uma heurística, ainda é necessário melhorias para que ele consiga resolver todos problemas disponíveis nesse branch. A repositório onde se encontra o desenvolvimento contínuo desse programa se encontra aqui: git@github.com:gogo40/gogoSokoban.git */ #include #include #include #include #include #include #include #include #include #include using namespace std; /* Estrutura de dados para representar um estado do problema Alfabeto do jogo: '.' espaco vazio '#' parede 'I' personagem 'J' personagem no destino 'x' destino caixa 'o' caixa 'O' caixa no destino */ static int mask[600]; static char rm[8]; void initCState() { mask['.'] = 0; rm[0] = '.'; mask['#'] = 1; rm[1] = '#'; mask['I'] = 2; rm[2] = 'I'; mask['J'] = 3; rm[3] = 'J'; mask['x'] = 4; rm[4] = 'x'; mask['o'] = 5; rm[5] = 'o'; mask['O'] = 6; rm[6] = 'O'; } /* Nós representamos um estado por meio de palavra de (N*M)/10 bytes, onde N e M são as dimensões da grade do sokoban */ class cState { public: cState(const cState& s) { N = s.N; M = s.M; v = s.v; } cState(int N = 0, int M = 0) : N(N), M(M), v( (N*M)/10 + 1, 0) {} char get(int i, int j) { int k = i * M + j; int p = k / 10; int n = k % 10; int value = (v[p] >> (3 * n) ) & 7; return rm[value]; } void insert(int i, int j, char c) { int value = mask[c]; int k = i * M + j; int p = k / 10; int n = k % 10; int w = v[p] & (7 << (3*n)); v[p] ^= w; v[p] |= value << (3 * n); } cState& operator=(const cState& x) { N = x.N; M = x.M; v = x.v; return *this; } void print() { for (int i = 0; i < N; ++i) { for (int j = 0; j < M; ++j) { printf("%c", get(i, j)); } printf("\n"); } } friend bool operator<(const cState& a, const cState& b); friend bool operator==(const cState& a, const cState& b); bool operator()(const cState& b) { if (N > b.N or M > b.M) return false; if (*this == b) return false; for (int i = 0; i < v.size(); ++i) if (v[i] > b.v[i]) { printf("false...\n"); return false; } printf("true...\n"); return true; } private: int N, M; vector v; }; /* Verifica se dois estados são iguais*/ bool operator==(const cState& a, const cState& b) { for (int i = 0; i < a.v.size(); ++i) if (a.v[i] != b.v[i]) { return false; } return true; } /* realiza a comparação lexicográfica dos dois estados*/ bool operator<(const cState& a, const cState& b) { return lexicographical_compare(a.v.begin(), a.v.end(), b.v.begin(), b.v.end()); } /////////////////////////////////////////////////////// int N, M; /* Movimentações possíveis pelo jogador do sokoban*/ int dx[] = {-1, 1, 0, 0}; int dy[] = { 0, 0, -1, 1}; typedef pair State; typedef pair pState; vector vs; vector > vbox; map ids; /*Imprime um estado*/ void print(cState& s) { s.print(); cout << endl; } /*Transforma um estado numa string*/ string getStr(cState& s) { string out = ""; for (int i = 0; i < N; ++i) for (int j = 0; j < M; ++j) out += s.get(i, j); return out; } /* Transforma uma string num grafo de estado*/ cState getVec(string& s) { cState v(N, M); int n = 0; for (int i = 0; i < N; ++i) for (int j = 0; j < M; ++j){ v.insert(i, j, s[n]); ++n; } return v; } /*Destinos das caixas*/ vector pfx; vector pfy; inline int abs(int a) { return a>0?a:-a; } /*Calcula estimativa de jogadas que faltam pra concluir o sokoban*/ int h(cState& s, int p, int id) { int d = 0; int x = p/M; int y = p%M; int nc = 0; for (int n = 0; n < vbox[id].size(); ++n) { int i = vbox[id][n] / M; int j = vbox[id][n] % M; if (s.get(i, j) == 'o') { int dv = 2*(N + M); for (int k = 0; k < pfx.size(); ++k) { int dx = abs(pfx[k] - i); int dy = abs(pfy[k] - j); int dp = (dx+dy); if (dp < dv) dv = dp; } d += dv; nc++; } } return d; } /*Verifica se chegamos num estado "morto"*/ bool isDead(cState& s, int id) { bool ok = false; /* ## #o (i-1, j+1) ## o# (i+1, j+1) o# ## (i+1, j-1) #o ## (i-1, j-1) */ for (int n = 0; n < vbox[id].size(); ++n) { int i = vbox[id][n] / M; int j = vbox[id][n] % M; if (s.get(i, j) == 'o') { if ((s.get(i-1, j) == '#' and s.get(i, j+1) == '#') or (s.get(i+1, j) == '#' and s.get(i, j+1) == '#') or (s.get(i+1, j) == '#' and s.get(i, j-1) == '#') or (s.get(i-1, j) == '#' and s.get(i, j-1) == '#') ) { ok = true; break; } } } return ok; } /*Realiza um movimento*/ bool makeMove(cState& s, int x, int y, int k) { int px = x + dx[k]; int py = y + dy[k]; if (not (px > -1 and px < N and py > -1 and py < M)) { return false; } switch (s.get(px, py)) { case '.': s.insert(px, py, 'o'); break; case 'x': s.insert(px, py, 'O'); break; default: return false; } return true; } /*Calcula a distância entre uma caixa e um posição final para a mesma. Simula o jogador realizando o movimento na caixa*/ int calcDist(cState& s, int x, int y, int xf, int yf) { map D; queue Q; int ini, fim; ini = fim = 0; Q.push(x * M + y); D[x * M + y] = 0; while (not Q.empty()) { int u = Q.front(); int du = D[u]; int ux = u / M; int uy = u % M; if (ux == xf and uy == yf) break; Q.pop(); for (int k = 0; k < 4; ++k) { int vx = ux + dx[k]; int vy = uy + dy[k]; int v = vx * M +vy; if (vx > -1 and vx < N and vy > -1 and vy < M) if (s.get(vx, vy) == '.' || s.get(vx, vy) == 'x') { if (D.find(v) == D.end() || D[v] > du + 1) { D[v] = du + 1; Q.push(v); } } } } return D.find(xf * M + yf) == D.end()? -1 : D[xf * M + yf]; } State ini, fim; map pi; /* Imprime a solução */ void print_sol(State& u, int p, int du) { if (u == ini) return; print_sol(pi[u], p + 1, du); if (u == fim) return; cState m = vs[u.first]; int po = u.second; int x = po/M; int y = po%M; m.insert(x, y, 'I'); cout<< du - p<< endl; print(m); } /* Localiza a caixa na grade*/ void findBox(vector& vb, cState& s) { for (int i = 0; i < N; ++i) for (int j = 0; j < M; ++j) if (s.get(i, j) == 'o' || s.get(i, j) == 'O') { vb.push_back(i * M + j); } } int main() { srand(time(NULL)); initCState(); /*Lê o estado inicial do jogo*/ cin>>N>>M; cState s(N, M), f(N, M); for (int i = 0; i < N; ++i) { string a; cin>>a; for (int j = 0; j < M; ++j) { f.insert(i, j, a[j]); s.insert(i, j, a[j]); } } /* Alfabeto do jogo: '.' espaco vazio '#' parede 'I' personagem 'J' personagem no destino 'x' destino caixa 'o' caixa 'O' caixa no destino */ int xo, yo, po; pfx.clear(); pfy.clear(); /* Localiza elementos importantes da grade*/ for (int i = 0; i < N; ++i) for (int j = 0; j < M; ++j) if (s.get(i, j) == 'I') { f.insert(i, j, '.'); s.insert(i, j, '.'); po = i * M +j; xo = i; yo = j; }else if (s.get(i, j) == 'J') { s.insert(i, j, 'x'); f.insert(i, j, 'O'); po = i * M +j; xo = i; yo = j; } else if (s.get(i, j) == 'x') { f.insert(i, j, 'O'); pfx.push_back(i); pfy.push_back(j); } else if (s.get(i, j) == 'o') { f.insert(i, j, '.'); } else { f.insert(i, j, s.get(i,j)); } /*Localiza caixas*/ vs.push_back(s); vbox.push_back(vector()); findBox(vbox[0], s); ids[s] = 0; vs.push_back(f); vbox.push_back(vector()); findBox(vbox[1], f); ids[f] = 1; ini.first = 0; ini.second = po; fim.first = 1; fim.second = -1; pi.clear(); map D; D[ini] = 0; bool ok = false; int ck = 1; int dmin = 1<<20; /* Tenta-se estimar quantas jogadas são necessárias para se concluir o jogo caso a profundidade da busca ultrapasse L, então a busca é encerrada. O L é o "branch factor" do algoritmo.*/ for (int L = 250; L < 1000; L *= 2) { if (ok) break; priority_queue Q; D.clear(); Q.push(pState(0, ini)); D[ini] = 0; while (!Q.empty()) { int uest = -Q.top().first; State u = Q.top().second; int du = D[u]; if (u == fim){ ok = true; dmin = du; break; } int p = u.second; int x = p / M; int y = p % M; Q.pop(); if ( uest > L or uest >= dmin) continue; else if (u == fim){ dmin = du; } if (ck % 50000 == 0) { cerr << du << " dmin= " << dmin << endl; } ++ck; /* Para cada estado u, realiza-se uma busca nos 4 estados adjascentes. */ for (int nb = 0; nb < vbox[u.first].size(); ++nb){ int i = vbox[u.first][nb] / M; int j = vbox[u.first][nb] % M; if (vs[u.first].get(i, j) == 'o' || vs[u.first].get(i, j) == 'O') { int q = i * M + j; for (int k = 0; k < 4; ++k) { cState m = vs[u.first]; if (makeMove(m, i, j, k)) { m.insert(i, j, (vs[u.first].get(i, j) =='o')?'.':'x'); int xf = i - dx[k]; int yf = j - dy[k]; int dup = calcDist(vs[u.first], x, y, xf, yf); if (dup > -1) { State v; if (ids.find(m) == ids.end()) { v.first = ids[m] = vs.size(); vbox.push_back(vector()); findBox(vbox[vs.size()], m); vs.push_back(m); } else v.first = ids[m]; if (isDead(m, v.first)) continue; if (v.first == fim.first) q = -1; v.second = q; if (D.find(v) == D.end()) { D[v] = du + dup + 1; pi[v]= u; int est = du + dup + 1 + h(m, p, v.first); if (est < dmin and est < L) Q.push(pState(-est, v)); } else if (D[v] > du + dup + 1) { D[v] = du + dup + 1; pi[v] = u; int est = du + dup + 1 + h(m, p, v.first); if (est < dmin and est < L) Q.push(pState(-est, v)); } } } } } } } } if (ok) { print_sol(fim, 0, D[fim]); } else { cout << "[Nao ha solucao... =(]\n"; } return 0; } ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.in ================================================ 9 9 ######### #I..##### #.oo##### #.o.###x# ###.###x# ###....x# ##...#..# ##...#### ######### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.out ================================================ 59 ######### #...##### #.oI##### #.oo###x# ###.###x# ###....x# ##...#..# ##...#### ######### 60 ######### #...##### #.o.##### #.oI###x# ###o###x# ###....x# ##...#..# ##...#### ######### 61 ######### #...##### #.o.##### #.o.###x# ###I###x# ###o...x# ##...#..# ##...#### ######### 62 ######### #...##### #.o.##### #.o.###x# ###.###x# ###I...x# ##.o.#..# ##...#### ######### 63 ######### #...##### #.o.##### #.o.###x# ###.###x# ###....x# ##.Io#..# ##...#### ######### 64 ######### #...##### #.o.##### #.o.###x# ###.###x# ###.o..x# ##..I#..# ##...#### ######### 65 ######### #...##### #.Io##### #.o.###x# ###.###x# ###.o..x# ##...#..# ##...#### ######### 66 ######### #...##### #..I##### #.oo###x# ###.###x# ###.o..x# ##...#..# ##...#### ######### 67 ######### #...##### #...##### #.oI###x# ###o###x# ###.o..x# ##...#..# ##...#### ######### 68 ######### #...##### #...##### #.o.###x# ###I###x# ###oo..x# ##...#..# ##...#### ######### 69 ######### #...##### #...##### #.o.###x# ###.###x# ###Io..x# ##.o.#..# ##...#### ######### 70 ######### #...##### #...##### #.o.###x# ###.###x# ###.Io.x# ##.o.#..# ##...#### ######### 71 ######### #...##### #...##### #.o.###x# ###.###x# ###..Iox# ##.o.#..# ##...#### ######### 72 ######### #...##### #...##### #.o.###x# ###.###x# ###...IO# ##.o.#..# ##...#### ######### 73 ######### #...##### #...##### #.o.###x# ###.###O# ###....I# ##.o.#..# ##...#### ######### 74 ######### #...##### #...##### #.o.###O# ###.###I# ###....x# ##.o.#..# ##...#### ######### 75 ######### #...##### #...##### #.o.###O# ###.###x# ###....x# ##.Io#..# ##...#### ######### 76 ######### #...##### #...##### #.o.###O# ###.###x# ###.o..x# ##..I#..# ##...#### ######### 77 ######### #...##### #...##### #.Io###O# ###.###x# ###.o..x# ##...#..# ##...#### ######### 78 ######### #...##### #...##### #..I###O# ###o###x# ###.o..x# ##...#..# ##...#### ######### 79 ######### #...##### #...##### #...###O# ###I###x# ###oo..x# ##...#..# ##...#### ######### 80 ######### #...##### #...##### #...###O# ###.###x# ###Io..x# ##.o.#..# ##...#### ######### 81 ######### #...##### #...##### #...###O# ###.###x# ###.Io.x# ##.o.#..# ##...#### ######### 82 ######### #...##### #...##### #...###O# ###.###x# ###..Iox# ##.o.#..# ##...#### ######### 83 ######### #...##### #...##### #...###O# ###.###x# ###...IO# ##.o.#..# ##...#### ######### 84 ######### #...##### #...##### #...###O# ###.###O# ###....I# ##.o.#..# ##...#### ######### 85 ######### #...##### #...##### #...###O# ###.###O# ###....x# ##.Io#..# ##...#### ######### 86 ######### #...##### #...##### #...###O# ###.###O# ###.o..x# ##..I#..# ##...#### ######### 87 ######### #...##### #...##### #...###O# ###.###O# ###.Io.x# ##...#..# ##...#### ######### 88 ######### #...##### #...##### #...###O# ###.###O# ###..Iox# ##...#..# ##...#### ######### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.sol ================================================ 59 ######### #...##### #.oI##### #.oo###x# ###.###x# ###....x# ##...#..# ##...#### ######### 60 ######### #...##### #.o.##### #.oI###x# ###o###x# ###....x# ##...#..# ##...#### ######### 61 ######### #...##### #.o.##### #.o.###x# ###I###x# ###o...x# ##...#..# ##...#### ######### 62 ######### #...##### #.o.##### #.o.###x# ###.###x# ###I...x# ##.o.#..# ##...#### ######### 63 ######### #...##### #.o.##### #.o.###x# ###.###x# ###....x# ##.Io#..# ##...#### ######### 64 ######### #...##### #.o.##### #.o.###x# ###.###x# ###.o..x# ##..I#..# ##...#### ######### 65 ######### #...##### #.Io##### #.o.###x# ###.###x# ###.o..x# ##...#..# ##...#### ######### 66 ######### #...##### #..I##### #.oo###x# ###.###x# ###.o..x# ##...#..# ##...#### ######### 67 ######### #...##### #...##### #.oI###x# ###o###x# ###.o..x# ##...#..# ##...#### ######### 68 ######### #...##### #...##### #.o.###x# ###I###x# ###oo..x# ##...#..# ##...#### ######### 69 ######### #...##### #...##### #.o.###x# ###.###x# ###Io..x# ##.o.#..# ##...#### ######### 70 ######### #...##### #...##### #.o.###x# ###.###x# ###.Io.x# ##.o.#..# ##...#### ######### 71 ######### #...##### #...##### #.o.###x# ###.###x# ###..Iox# ##.o.#..# ##...#### ######### 72 ######### #...##### #...##### #.o.###x# ###.###x# ###...IO# ##.o.#..# ##...#### ######### 73 ######### #...##### #...##### #.o.###x# ###.###O# ###....I# ##.o.#..# ##...#### ######### 74 ######### #...##### #...##### #.o.###O# ###.###I# ###....x# ##.o.#..# ##...#### ######### 75 ######### #...##### #...##### #.o.###O# ###.###x# ###....x# ##.Io#..# ##...#### ######### 76 ######### #...##### #...##### #.o.###O# ###.###x# ###.o..x# ##..I#..# ##...#### ######### 77 ######### #...##### #...##### #.Io###O# ###.###x# ###.o..x# ##...#..# ##...#### ######### 78 ######### #...##### #...##### #..I###O# ###o###x# ###.o..x# ##...#..# ##...#### ######### 79 ######### #...##### #...##### #...###O# ###I###x# ###oo..x# ##...#..# ##...#### ######### 80 ######### #...##### #...##### #...###O# ###.###x# ###Io..x# ##.o.#..# ##...#### ######### 81 ######### #...##### #...##### #...###O# ###.###x# ###.Io.x# ##.o.#..# ##...#### ######### 82 ######### #...##### #...##### #...###O# ###.###x# ###..Iox# ##.o.#..# ##...#### ######### 83 ######### #...##### #...##### #...###O# ###.###x# ###...IO# ##.o.#..# ##...#### ######### 84 ######### #...##### #...##### #...###O# ###.###O# ###....I# ##.o.#..# ##...#### ######### 85 ######### #...##### #...##### #...###O# ###.###O# ###....x# ##.Io#..# ##...#### ######### 86 ######### #...##### #...##### #...###O# ###.###O# ###.o..x# ##..I#..# ##...#### ######### 87 ######### #...##### #...##### #...###O# ###.###O# ###.Io.x# ##...#..# ##...#### ######### 88 ######### #...##### #...##### #...###O# ###.###O# ###..Iox# ##...#..# ##...#### ######### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.in ================================================ 9 10 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.o.I.## ###.....## ########## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.out ================================================ 28 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.Io..## ###.....## ########## 29 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###..Io.## ###.....## ########## 30 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###...Io## ###.....## ########## 31 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#o## ###....I## ###.....## ########## 32 ########## #xx......# #xxo..#..# #..#o##.## #.o....o## #####.#I## ###.....## ###.....## ########## 33 ########## #xx......# #xxo..#..# #..#o##o## #.o....I## #####.#.## ###.....## ###.....## ########## 34 ########## #xx......# #xxo..#o.# #..#o##I## #.o.....## #####.#.## ###.....## ###.....## ########## 35 ########## #xx....o.# #xxo..#I.# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 36 ########## #xx...oI.# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 37 ########## #xx..oI..# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 38 ########## #xx.oI...# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 39 ########## #xxoI....# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 40 ########## #xOI.....# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 41 ########## #OI......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 42 ########## #Ox......# #xOI..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 43 ########## #Ox......# #OI...#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 44 ########## #Ox......# #Ox...#..# #..#o##.## #.Io....## #####.#.## ###.....## ###.....## ########## 45 ########## #Ox......# #Ox...#..# #..#o##.## #..Io...## #####.#.## ###.....## ###.....## ########## 46 ########## #Ox......# #Ox...#..# #..#o##.## #...Io..## #####.#.## ###.....## ###.....## ########## 47 ########## #Ox......# #Ox.o.#..# #..#I##.## #....o..## #####.#.## ###.....## ###.....## ########## 48 ########## #Ox......# #Ox.o.#..# #..#.##.## #....Io.## #####.#.## ###.....## ###.....## ########## 49 ########## #Ox......# #Ox.o.#..# #..#.##.## #.....Io## #####.#.## ###.....## ###.....## ########## 50 ########## #Ox......# #Ox.o.#..# #..#.##o## #......I## #####.#.## ###.....## ###.....## ########## 51 ########## #Ox......# #Ox.o.#o.# #..#.##I## #.......## #####.#.## ###.....## ###.....## ########## 52 ########## #Ox....o.# #Ox.o.#I.# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 53 ########## #Ox...oI.# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 54 ########## #Ox..oI..# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 55 ########## #Ox.oI...# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 56 ########## #OxoI....# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 57 ########## #OOI.....# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 58 ########## #OO......# #OxoI.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.sol ================================================ 28 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.Io..## ###.....## ########## 29 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###..Io.## ###.....## ########## 30 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###...Io## ###.....## ########## 31 ########## #xx......# #xxo..#..# #..#o##.## #.o.....## #####.#o## ###....I## ###.....## ########## 32 ########## #xx......# #xxo..#..# #..#o##.## #.o....o## #####.#I## ###.....## ###.....## ########## 33 ########## #xx......# #xxo..#..# #..#o##o## #.o....I## #####.#.## ###.....## ###.....## ########## 34 ########## #xx......# #xxo..#o.# #..#o##I## #.o.....## #####.#.## ###.....## ###.....## ########## 35 ########## #xx....o.# #xxo..#I.# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 36 ########## #xx...oI.# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 37 ########## #xx..oI..# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 38 ########## #xx.oI...# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 39 ########## #xxoI....# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 40 ########## #xOI.....# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 41 ########## #OI......# #xxo..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 42 ########## #Ox......# #xOI..#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 43 ########## #Ox......# #OI...#..# #..#o##.## #.o.....## #####.#.## ###.....## ###.....## ########## 44 ########## #Ox......# #Ox...#..# #..#o##.## #.Io....## #####.#.## ###.....## ###.....## ########## 45 ########## #Ox......# #Ox...#..# #..#o##.## #..Io...## #####.#.## ###.....## ###.....## ########## 46 ########## #Ox......# #Ox...#..# #..#o##.## #...Io..## #####.#.## ###.....## ###.....## ########## 47 ########## #Ox......# #Ox.o.#..# #..#I##.## #....o..## #####.#.## ###.....## ###.....## ########## 48 ########## #Ox......# #Ox.o.#..# #..#.##.## #....Io.## #####.#.## ###.....## ###.....## ########## 49 ########## #Ox......# #Ox.o.#..# #..#.##.## #.....Io## #####.#.## ###.....## ###.....## ########## 50 ########## #Ox......# #Ox.o.#..# #..#.##o## #......I## #####.#.## ###.....## ###.....## ########## 51 ########## #Ox......# #Ox.o.#o.# #..#.##I## #.......## #####.#.## ###.....## ###.....## ########## 52 ########## #Ox....o.# #Ox.o.#I.# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 53 ########## #Ox...oI.# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 54 ########## #Ox..oI..# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 55 ########## #Ox.oI...# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 56 ########## #OxoI....# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 57 ########## #OOI.....# #Ox.o.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## 58 ########## #OO......# #OxoI.#..# #..#.##.## #.......## #####.#.## ###.....## ###.....## ########## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.in ================================================ 8 6 ###### ##..## #Io.## ##o.## ##.o.# #xo..# #xxOx# ###### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.out ================================================ 20 ###### ##..## #.Io## ##o.## ##.o.# #xo..# #xxOx# ###### 21 ###### ##..## #..o## ##I.## ##oo.# #xo..# #xxOx# ###### 22 ###### ##..## #..o## ##..## ##oI.# #xoo.# #xxOx# ###### 23 ###### ##..## #..o## ##..## ##o..# #xoo.# #xOIx# ###### 24 ###### ##..## #..o## ##..## ##o..# #xoo.# #OIxx# ###### 25 ###### ##..## #..o## ##..## ##o..# #xoI.# #OxOx# ###### 26 ###### ##..## #..o## ##..## ##o..# #OI..# #OxOx# ###### 27 ###### ##..## #..o## ##..## ##o..# #O...# #OxIO# ###### 28 ###### ##..## #..o## ##..## ##I..# #Oo..# #OxxO# ###### 29 ###### ##..## #..o## ##..## ##...# #OI..# #OOxO# ###### 30 ###### ##..## #..I## ##.o## ##...# #O...# #OOxO# ###### 31 ###### ##..## #...## ##.I## ##.o.# #O...# #OOxO# ###### 32 ###### ##..## #...## ##..## ##.I.# #O.o.# #OOxO# ###### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.sol ================================================ 20 ###### ##..## #.Io## ##o.## ##.o.# #xo..# #xxOx# ###### 21 ###### ##..## #..o## ##I.## ##oo.# #xo..# #xxOx# ###### 22 ###### ##..## #..o## ##..## ##oI.# #xoo.# #xxOx# ###### 23 ###### ##..## #..o## ##..## ##o..# #xoo.# #xOIx# ###### 24 ###### ##..## #..o## ##..## ##o..# #xoo.# #OIxx# ###### 25 ###### ##..## #..o## ##..## ##o..# #xoI.# #OxOx# ###### 26 ###### ##..## #..o## ##..## ##o..# #OI..# #OxOx# ###### 27 ###### ##..## #..o## ##..## ##o..# #O...# #OxIO# ###### 28 ###### ##..## #..o## ##..## ##I..# #Oo..# #OxxO# ###### 29 ###### ##..## #..o## ##..## ##...# #OI..# #OOxO# ###### 30 ###### ##..## #..I## ##.o## ##...# #O...# #OOxO# ###### 31 ###### ##..## #...## ##.I## ##.o.# #O...# #OOxO# ###### 32 ###### ##..## #...## ##..## ##.I.# #O.o.# #OOxO# ###### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.in ================================================ 8 8 ######## ##I.#### ##.o..## ###.#.## #x#.#..# #xo..#.# #x...o.# ######## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.out ================================================ 40 ######## ##..#### ##.I..## ###o#.## #x#.#..# #xo..#.# #x...o.# ######## 41 ######## ##..#### ##....## ###o#.## #x#.#..# #xo..#.# #x..oI.# ######## 42 ######## ##..#### ##....## ###o#.## #x#.#..# #xo..#.# #x.oI..# ######## 43 ######## ##..#### ##....## ###o#.## #x#.#..# #OI..#.# #x.o...# ######## 44 ######## ##..#### ##....## ###o#.## #O#.#..# #I...#.# #x.o...# ######## 45 ######## ##..#### ##....## ###o#.## #O#.#..# #x...#.# #xoI...# ######## 46 ######## ##..#### ##....## ###o#.## #O#.#..# #x...#.# #OI....# ######## 47 ######## ##..#### ##....## ###I#.## #O#o#..# #x...#.# #O.....# ######## 48 ######## ##..#### ##....## ###.#.## #O#I#..# #x.o.#.# #O.....# ######## 49 ######## ##..#### ##....## ###.#.## #O#.#..# #xoI.#.# #O.....# ######## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.sol ================================================ 40 ######## ##..#### ##.I..## ###o#.## #x#.#..# #xo..#.# #x...o.# ######## 41 ######## ##..#### ##....## ###o#.## #x#.#..# #xo..#.# #x..oI.# ######## 42 ######## ##..#### ##....## ###o#.## #x#.#..# #xo..#.# #x.oI..# ######## 43 ######## ##..#### ##....## ###o#.## #x#.#..# #OI..#.# #x.o...# ######## 44 ######## ##..#### ##....## ###o#.## #O#.#..# #I...#.# #x.o...# ######## 45 ######## ##..#### ##....## ###o#.## #O#.#..# #x...#.# #xoI...# ######## 46 ######## ##..#### ##....## ###o#.## #O#.#..# #x...#.# #OI....# ######## 47 ######## ##..#### ##....## ###I#.## #O#o#..# #x...#.# #O.....# ######## 48 ######## ##..#### ##....## ###.#.## #O#I#..# #x.o.#.# #O.....# ######## 49 ######## ##..#### ##....## ###.#.## #O#.#..# #xoI.#.# #O.....# ######## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.in ================================================ 7 10 ########## ##.....### ##o###...# #.I.o..o.# #.xx#.o.## ##xx#...## ########## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.out ================================================ 88 ########## ##.....### ##o###...# #...Io.o.# #.xx#.o.## ##xx#...## ########## 89 ########## ##.....### ##o###...# #....Ioo.# #.xx#.o.## ##xx#...## ########## 90 ########## ##.....### ##o###.o.# #.....oI.# #.xx#.o.## ##xx#...## ########## 91 ########## ##.....### ##o###.o.# #....oI..# #.xx#.o.## ##xx#...## ########## 92 ########## ##.....### ##I###.o.# #.o..o...# #.xx#.o.## ##xx#...## ########## 93 ########## ##.....### ##.###.o.# #.I..o...# #.Ox#.o.## ##xx#...## ########## 94 ########## ##.....### ##.###.o.# #....o...# #.Ix#.o.## ##Ox#...## ########## 95 ########## ##.....### ##.###.o.# #...oI...# #.xx#.o.## ##Ox#...## ########## 96 ########## ##.....### ##.###.o.# #..oI....# #.xx#.o.## ##Ox#...## ########## 97 ########## ##.....### ##.###.o.# #.oI.....# #.xx#.o.## ##Ox#...## ########## 98 ########## ##.....### ##.###.o.# #.I......# #.Ox#.o.## ##Ox#...## ########## 99 ########## ##.....### ##.###.o.# #........# #.IO#.o.## ##Ox#...## ########## 100 ########## ##.....### ##.###oI.# #........# #.xO#.o.## ##Ox#...## ########## 101 ########## ##.....### ##.###I..# #.....o..# #.xO#.o.## ##Ox#...## ########## 102 ########## ##.....### ##.###...# #....oI..# #.xO#.o.## ##Ox#...## ########## 103 ########## ##.....### ##.###...# #...oI...# #.xO#.o.## ##Ox#...## ########## 104 ########## ##.....### ##.###...# #..oI....# #.xO#.o.## ##Ox#...## ########## 105 ########## ##.....### ##.###...# #.oI.....# #.xO#.o.## ##Ox#...## ########## 106 ########## ##.....### ##.###...# #.o......# #.xI#.o.## ##OO#...## ########## 107 ########## ##.....### ##.###...# #.I......# #.Ox#.o.## ##OO#...## ########## 108 ########## ##.....### ##.###...# #........# #.IO#.o.## ##OO#...## ########## 109 ########## ##.....### ##.###...# #.....o..# #.xO#.I.## ##OO#...## ########## 110 ########## ##.....### ##.###...# #....oI..# #.xO#...## ##OO#...## ########## 111 ########## ##.....### ##.###...# #...oI...# #.xO#...## ##OO#...## ########## 112 ########## ##.....### ##.###...# #..oI....# #.xO#...## ##OO#...## ########## 113 ########## ##.....### ##.###...# #.oI.....# #.xO#...## ##OO#...## ########## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.sol ================================================ 88 ########## ##.....### ##o###...# #...Io.o.# #.xx#.o.## ##xx#...## ########## 89 ########## ##.....### ##o###...# #....Ioo.# #.xx#.o.## ##xx#...## ########## 90 ########## ##.....### ##o###.o.# #.....oI.# #.xx#.o.## ##xx#...## ########## 91 ########## ##.....### ##o###.o.# #....oI..# #.xx#.o.## ##xx#...## ########## 92 ########## ##.....### ##I###.o.# #.o..o...# #.xx#.o.## ##xx#...## ########## 93 ########## ##.....### ##.###.o.# #.I..o...# #.Ox#.o.## ##xx#...## ########## 94 ########## ##.....### ##.###.o.# #....o...# #.Ix#.o.## ##Ox#...## ########## 95 ########## ##.....### ##.###.o.# #...oI...# #.xx#.o.## ##Ox#...## ########## 96 ########## ##.....### ##.###.o.# #..oI....# #.xx#.o.## ##Ox#...## ########## 97 ########## ##.....### ##.###.o.# #.oI.....# #.xx#.o.## ##Ox#...## ########## 98 ########## ##.....### ##.###.o.# #.I......# #.Ox#.o.## ##Ox#...## ########## 99 ########## ##.....### ##.###.o.# #........# #.IO#.o.## ##Ox#...## ########## 100 ########## ##.....### ##.###oI.# #........# #.xO#.o.## ##Ox#...## ########## 101 ########## ##.....### ##.###I..# #.....o..# #.xO#.o.## ##Ox#...## ########## 102 ########## ##.....### ##.###...# #....oI..# #.xO#.o.## ##Ox#...## ########## 103 ########## ##.....### ##.###...# #...oI...# #.xO#.o.## ##Ox#...## ########## 104 ########## ##.....### ##.###...# #..oI....# #.xO#.o.## ##Ox#...## ########## 105 ########## ##.....### ##.###...# #.oI.....# #.xO#.o.## ##Ox#...## ########## 106 ########## ##.....### ##.###...# #.o......# #.xI#.o.## ##OO#...## ########## 107 ########## ##.....### ##.###...# #.I......# #.Ox#.o.## ##OO#...## ########## 108 ########## ##.....### ##.###...# #........# #.IO#.o.## ##OO#...## ########## 109 ########## ##.....### ##.###...# #.....o..# #.xO#.I.## ##OO#...## ########## 110 ########## ##.....### ##.###...# #....oI..# #.xO#...## ##OO#...## ########## 111 ########## ##.....### ##.###...# #...oI...# #.xO#...## ##OO#...## ########## 112 ########## ##.....### ##.###...# #..oI....# #.xO#...## ##OO#...## ########## 113 ########## ##.....### ##.###...# #.oI.....# #.xO#...## ##OO#...## ########## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.in ================================================ 13 11 ########### ########I.# ########..# ####......# #...x###.## #.#.#....## #.#.o.o#x.# #.#..O..#.# #.x#o.o.#.# ##....#.#.# ##.###x...# ##.....#### ########### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.out ================================================ ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.sol ================================================ 107 ########### ########..# ########..# ####......# #...x###.## #.#.#....## #.#oI.o#x.# #.#..O..#.# #.x#o.o.#.# ##....#.#.# ##.###x...# ##.....#### ########### 108 ########### ########..# ########..# ####......# #...x###.## #.#.#....## #.#o..o#x.# #.#..O..#.# #.x#I.o.#.# ##..o.#.#.# ##.###x...# ##.....#### ########### 109 ########### ########..# ########..# ####......# #...x###.## #.#.#....## #.#o..o#x.# #.#..O..#.# #.x#..o.#.# ##.oI.#.#.# ##.###x...# ##.....#### ########### 110 ########### ########..# ########..# ####......# #...x###.## #.#o#....## #.#I..o#x.# #.#..O..#.# #.x#..o.#.# ##.o..#.#.# ##.###x...# ##.....#### ########### 111 ########### ########..# ########..# ####......# #..ox###.## #.#I#....## #.#...o#x.# #.#..O..#.# #.x#..o.#.# ##.o..#.#.# ##.###x...# ##.....#### ########### 112 ########### ########..# ########..# ####......# #..ox###.## #.#.#....## #.#...o#x.# #.#..I..#.# #.x#.oo.#.# ##.o..#.#.# ##.###x...# ##.....#### ########### 113 ########### ########..# ########..# ####......# #..IO###.## #.#.#....## #.#...o#x.# #.#..x..#.# #.x#.oo.#.# ##.o..#.#.# ##.###x...# ##.....#### ########### 114 ########### ########..# ########..# ####......# #...O###.## #.#.#....## #.#...o#x.# #.#..x..#.# #.x#.oo.#.# ##oI..#.#.# ##.###x...# ##.....#### ########### 115 ########### ########..# ########..# ####......# #...O###.## #.#.#....## #.#...o#x.# #.#..x..#.# #.O#.oo.#.# ##I...#.#.# ##.###x...# ##.....#### ########### 116 ########### ########..# ########..# ####......# #...O###.## #.#.#....## #.#...o#x.# #.#..O..#.# #.O#.Io.#.# ##....#.#.# ##.###x...# ##.....#### ########### 117 ########### ########..# ########..# ####......# #...O###.## #.#.#....## #.#...o#x.# #.#..O..#.# #.O#..Io#.# ##....#.#.# ##.###x...# ##.....#### ########### 118 ########### ########..# ########..# ####......# #...O###.## #.#.#....## #.#...o#x.# #.#..O..#.# #.O#...I#.# ##....#o#.# ##.###x...# ##.....#### ########### 119 ########### ########..# ########..# ####......# #...O###.## #.#.#....## #.#...o#x.# #.#..O..#.# #.O#....#.# ##....#I#.# ##.###xo..# ##.....#### ########### 120 ########### ########..# ########..# ####......# #...O###.## #.#.#....## #.#...o#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###OI..# ##.....#### ########### 121 ########### ########..# ########..# ####......# #...O###.## #.#.#.o..## #.#...I#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### 122 ########### ########..# ########..# ####......# #...O###.## #.#.#.Io.## #.#....#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### 123 ########### ########..# ########..# ####......# #...O###.## #.#.#..Io## #.#....#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### 124 ########### ########..# ########..# ####......# #...O###o## #.#.#...I## #.#....#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### 125 ########### ########..# ########..# ####....o.# #...O###I## #.#.#....## #.#....#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### 126 ########### ########..# ########o.# ####....I.# #...O###.## #.#.#....## #.#....#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### 127 ########### ########..# ########I.# ####....o.# #...O###.## #.#.#....## #.#....#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### 128 ########### ########..# ########..# ####....I.# #...O###o## #.#.#....## #.#....#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### 129 ########### ########..# ########..# ####......# #...O###I## #.#.#...o## #.#....#x.# #.#..O..#.# #.O#....#.# ##....#.#.# ##.###O...# ##.....#### ########### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.in ================================================ 8 9 ######### ###..#.I# ##...#..# ##o.o.o.# ##.o##..# ##.o.#.## xxxxx..## ######### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.sol ================================================ 50 ######### ###..#..# ##...#..# ##o.o.o.# ##.o##..# ##oI.#.## xxxxx..## ######### 51 ######### ###..#..# ##...#..# ##ooo.o.# ##.I##..# ##o..#.## xxxxx..## ######### 52 ######### ###..#..# ##.o.#..# ##oIo.o.# ##..##..# ##o..#.## xxxxx..## ######### 53 ######### ###..#..# ##.o.#..# ##o.Ioo.# ##..##..# ##o..#.## xxxxx..## ######### 54 ######### ###..#..# ##.I.#..# ##oo.oo.# ##..##..# ##o..#.## xxxxx..## ######### 55 ######### ###..#..# ##...#..# ##oI.oo.# ##.o##..# ##o..#.## xxxxx..## ######### 56 ######### ###..#..# ##...#..# ##o..oo.# ##.I##..# ##oo.#.## xxxxx..## ######### 57 ######### ###..#..# ##...#..# ##o..oo.# ##..##..# ##oI.#.## xxxOx..## ######### 58 ######### ###..#..# ##...#..# ##o..oo.# ##..##..# ##o..#.## xxOIx..## ######### 59 ######### ###..#..# ##...#..# ##o..oo.# ##..##..# ##o..#.## xOIxx..## ######### 60 ######### ###..#..# ##...#..# ##o..oo.# ##..##..# ##o..#.## OIxxx..## ######### 61 ######### ###..#..# ##...#..# ##o..oo.# ##..##..# ##I..#.## OxOxx..## ######### 62 ######### ###..#..# ##...#..# ##o..oo.# ##..##..# ##...#.## OOIxx..## ######### 63 ######### ###..#..# ##...#o.# ##o..oI.# ##..##..# ##...#.## OOxxx..## ######### 64 ######### ###..#..# ##...#o.# ##o.oI..# ##..##..# ##...#.## OOxxx..## ######### 65 ######### ###..#..# ##...#o.# ##ooI...# ##..##..# ##...#.## OOxxx..## ######### 66 ######### ###..#..# ##...#o.# ##oI....# ##.o##..# ##...#.## OOxxx..## ######### 67 ######### ###..#..# ##...#o.# ##o.....# ##.I##..# ##.o.#.## OOxxx..## ######### 68 ######### ###..#..# ##...#o.# ##o.....# ##..##..# ##.I.#.## OOxOx..## ######### 69 ######### ###..#..# ##...#o.# ##o.....# ##..##..# ##...#.## OOxIO..## ######### 70 ######### ###..#..# ##...#I.# ##o...o.# ##..##..# ##...#.## OOxxO..## ######### 71 ######### ###..#..# ##...#..# ##o..oI.# ##..##..# ##...#.## OOxxO..## ######### 72 ######### ###..#..# ##...#..# ##o.oI..# ##..##..# ##...#.## OOxxO..## ######### 73 ######### ###..#..# ##...#..# ##ooI...# ##..##..# ##...#.## OOxxO..## ######### 74 ######### ###..#..# ##...#..# ##oI....# ##.o##..# ##...#.## OOxxO..## ######### 75 ######### ###..#..# ##...#..# ##o.....# ##.I##..# ##.o.#.## OOxxO..## ######### 76 ######### ###..#..# ##...#..# ##o.....# ##..##..# ##.I.#.## OOxOO..## ######### 77 ######### ###..#..# ##...#..# ##I.....# ##o.##..# ##...#.## OOxOO..## ######### 78 ######### ###..#..# ##...#..# ##......# ##I.##..# ##o..#.## OOxOO..## ######### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.in ================================================ 7 10 ########## ####....## ##x.o##.## #xxo.o..I# #xx.o.o.## #####...## ########## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.sol ================================================ 29 ########## ####....## ##x.o##.## #xxooI...# #xx.o.o.## #####...## ########## 30 ########## ####....## ##x.o##.## #xxoo....# #xxoI.o.## #####...## ########## 31 ########## ####....## ##x.o##.## #xxoo....# #xOI..o.## #####...## ########## 32 ########## ####....## ##xoo##.## #xxIo....# #xO...o.## #####...## ########## 33 ########## ####....## ##xoo##.## #xx.o....# #OI...o.## #####...## ########## 34 ########## ####....## ##xoo##.## #xxoI....# #Ox...o.## #####...## ########## 35 ########## ####....## ##xoo##.## #xOI.....# #Ox...o.## #####...## ########## 36 ########## ####....## ##xoI##.## #xO.o....# #Ox...o.## #####...## ########## 37 ########## ####....## ##OI.##.## #xO.o....# #Ox...o.## #####...## ########## 38 ########## ####....## ##O..##.## #OI.o....# #Ox...o.## #####...## ########## 39 ########## ####....## ##O..##.## #OxoI....# #Ox...o.## #####...## ########## 40 ########## ####....## ##O..##.## #OOI.....# #Ox...o.## #####...## ########## 41 ########## ####....## ##O..##.## #OO......# #Ox..oI.## #####...## ########## 42 ########## ####....## ##O..##.## #OO......# #Ox.oI..## #####...## ########## 43 ########## ####....## ##O..##.## #OO......# #OxoI...## #####...## ########## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.in ================================================ 9 11 ########### ##..##...## ##...o...## ##o.###.o## ##.#xxx#.## ##.#xxx#.## #.o..o..o.# #.....#.I.# ########### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.sol ================================================ 130 ########### ##..##...## ##...o...## ##o.###.o## ##.#xxx#.## ##.#xOx#.## #.o..I..o.# #.....#...# ########### 131 ########### ##..##...## ##...o...## ##o.###.o## ##.#xxx#.## ##.#xIO#.## #.o.....o.# #.....#...# ########### 132 ########### ##..##...## ##...o...## ##o.###.o## ##.#xxx#.## ##.#xxO#.## #.o....oI.# #.....#...# ########### 133 ########### ##..##...## ##...o...## ##o.###.o## ##.#xxx#.## ##.#xxO#.## #.o...oI..# #.....#...# ########### 134 ########### ##..##...## ##...o...## ##o.###.o## ##.#xxx#.## ##.#xxO#.## #.o..oI...# #.....#...# ########### 135 ########### ##..##...## ##...o...## ##o.###.o## ##.#xxO#.## ##.#xxI#.## #.o..o....# #.....#...# ########### 136 ########### ##..##...## ##...o...## ##o.###.o## ##.#xxO#.## ##.#xxx#.## #.Io.o....# #.....#...# ########### 137 ########### ##..##...## ##o..o...## ##I.###.o## ##.#xxO#.## ##.#xxx#.## #..o.o....# #.....#...# ########### 138 ########### ##..##...## ##o..Io..## ##..###.o## ##.#xxO#.## ##.#xxx#.## #..o.o....# #.....#...# ########### 139 ########### ##..##...## ##o...Io.## ##..###.o## ##.#xxO#.## ##.#xxx#.## #..o.o....# #.....#...# ########### 140 ########### ##..##...## ##o....o.## ##..###.I## ##.#xxO#o## ##.#xxx#.## #..o.o....# #.....#...# ########### 141 ########### ##..##...## ##o....o.## ##..###..## ##.#xxO#I## ##.#xxx#o## #..o.o....# #.....#...# ########### 142 ########### ##..##...## ##o....o.## ##..###..## ##.#xxO#.## ##.#xxx#I## #..o.o..o.# #.....#...# ########### 143 ########### ##..##...## ##o....Io## ##..###..## ##.#xxO#.## ##.#xxx#.## #..o.o..o.# #.....#...# ########### 144 ########### ##..##...## ##o.....o## ##..###..## ##.#xxO#.## ##.#xxx#.## #..Ioo..o.# #.....#...# ########### 145 ########### ##..##...## ##o.....o## ##..###..## ##.#xxO#.## ##.#Oxx#.## #...Io..o.# #.....#...# ########### 146 ########### ##..##...## ##o.....o## ##..###..## ##.#xxO#.## ##.#OOx#.## #....I..o.# #.....#...# ########### 147 ########### ##..##...## ##o.....o## ##..###..## ##.#OxO#.## ##.#IOx#.## #.......o.# #.....#...# ########### 148 ########### ##..##...## ##o.....o## ##..###..## ##.#OxO#.## ##.#xIO#.## #.......o.# #.....#...# ########### 149 ########### ##..##...## ##o.....o## ##..###..## ##.#OxO#.## ##.#xxO#.## #......oI.# #.....#...# ########### 150 ########### ##..##...## ##o.....o## ##..###..## ##.#OxO#.## ##.#xxO#.## #.....oI..# #.....#...# ########### 151 ########### ##..##...## ##o.....o## ##..###..## ##.#OxO#.## ##.#xxO#.## #....oI...# #.....#...# ########### 152 ########### ##..##...## ##o.....I## ##..###.o## ##.#OxO#.## ##.#xxO#.## #....o....# #.....#...# ########### 153 ########### ##..##...## ##o......## ##..###.I## ##.#OxO#o## ##.#xxO#.## #....o....# #.....#...# ########### 154 ########### ##..##...## ##o......## ##..###..## ##.#OxO#I## ##.#xxO#o## #....o....# #.....#...# ########### 155 ########### ##..##...## ##o......## ##..###..## ##.#OxO#.## ##.#xxO#I## #....o..o.# #.....#...# ########### 156 ########### ##..##...## ##o......## ##..###..## ##.#OxO#.## ##.#xOO#.## #....I..o.# #.....#...# ########### 157 ########### ##..##...## ##o......## ##..###..## ##.#OxO#.## ##.#xOO#.## #......oI.# #.....#...# ########### 158 ########### ##..##...## ##I......## ##o.###..## ##.#OxO#.## ##.#xOO#.## #......o..# #.....#...# ########### 159 ########### ##..##...## ##.......## ##I.###..## ##o#OxO#.## ##.#xOO#.## #......o..# #.....#...# ########### 160 ########### ##..##...## ##.......## ##..###..## ##I#OxO#.## ##o#xOO#.## #......o..# #.....#...# ########### 161 ########### ##..##...## ##.......## ##..###..## ##.#OxO#.## ##I#xOO#.## #.o....o..# #.....#...# ########### 162 ########### ##..##...## ##.......## ##..###..## ##.#OxO#.## ##.#xOO#.## #.o...oI..# #.....#...# ########### 163 ########### ##..##...## ##.......## ##..###..## ##.#OxO#.## ##.#xOO#.## #.o..oI...# #.....#...# ########### 164 ########### ##..##...## ##.......## ##..###..## ##.#OxO#.## ##.#xOO#.## #.o.oI....# #.....#...# ########### 165 ########### ##..##...## ##.......## ##..###..## ##.#OOO#.## ##.#xIO#.## #.o.o.....# #.....#...# ########### 166 ########### ##..##...## ##.......## ##..###..## ##.#OOO#.## ##.#OxO#.## #.o.I.....# #.....#...# ########### 167 ########### ##..##...## ##.......## ##..###..## ##.#OOO#.## ##.#OxO#.## #.Io......# #.....#...# ########### 168 ########### ##..##...## ##.......## ##..###..## ##.#OOO#.## ##.#OxO#.## #..Io.....# #.....#...# ########### 169 ########### ##..##...## ##.......## ##..###..## ##.#OOO#.## ##.#OxO#.## #...Io....# #.....#...# ########### ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.in ================================================ 7 8 ######## #..#...# #.oxxo.# #IoxO.## #.oxxo.# #..#...# ######## ================================================ FILE: other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.sol ================================================ 41 ######## #..#...# #.IOxo.# #.oxO.## #.oxxo.# #..#...# ######## 42 ######## #..#...# #..Oxo.# #.oxO.## #.IOxo.# #..#...# ######## 43 ######## #..#...# #.oOxo.# #.IxO.## #..Oxo.# #..#...# ######## 44 ######## #..#...# #.oOxo.# #..xIo## #..Oxo.# #..#...# ######## 45 ######## #..#...# #.oOxo.# #..xxo## #.oIxo.# #..#...# ######## 46 ######## #..#...# #.oOxo.# #..xxo## #.oxOI.# #..#...# ######## 47 ######## #..#...# #.oOxo.# #..xxo## #.oOI..# #..#...# ######## 48 ######## #..#...# #.oOOI.# #..xxo## #.oOx..# #..#...# ######## 49 ######## #..#...# #.oOO..# #..xxI## #.oOxo.# #..#...# ######## 50 ######## #..#...# #.oOO..# #..xx.## #.oOOI.# #..#...# ######## 51 ######## #..#...# #.IOO..# #.oxx.## #.oOO..# #..#...# ######## 52 ######## #..#...# #..OO..# #.IOx.## #.oOO..# #..#...# ######## 53 ######## #..#...# #..OO..# #..IO.## #.oOO..# #..#...# ######## 54 ######## #..#...# #..OO..# #.oxO.## #.IOO..# #..#...# ######## ================================================ FILE: other-languages/ai/sudoku/sudoku.cpp ================================================ /* # -*- coding: utf-8 -*- """ Backtracking e Heurísticas aplicadas para se resolver um sudoku. A busca é feita no grafo de estados do problema Autores: ? Colaborador: Péricles Lopes Machado [gogo40] (pericles.raskolnikoff.gmail.com) Tipo: search Descrição: Sudokus são problema NP-difíceis, por isso na maior parte do tempo procuramos heurísticas que acelerem a busca. Nesse código são implementadas algumas heurísticas humanas, como limitar as opções de jogada em cada estado usando as regras do jogo. Existe uma solução mais eficiente utilizando-se o algoritmo X[5]. Futuramente, planejo implementar essa outra abordagem. Este código é apenas um exemplo de como heurísticas podem acelerar a busca de uma solução de sudoku. Complexidade: O(2^N) Dificuldade: Difícil Referências: [1] http://en.wikipedia.org/wiki/Backtracking [2] http://en.wikipedia.org/wiki/Heuristic [3] http://falapericles.blogspot.com.br/2009/05/grafo-de-estados-e-suas-aplicacoes.html [4] http://webdocs.cs.ualberta.ca/~games/Sokoban/ [5] http://en.wikipedia.org/wiki/Knuth%27s_Algorithm_X """ */ /* Para testar o código pode-se utilizar o seguinte problema do SPOJ brasil: http://br.spoj.com/problems/BSUDO/ Ou digitar no terminal a seguinte entrada (test_001.in): 1 103000509 002109400 000704000 300502006 060000050 700803004 000401000 009205800 804000107 O '0' representa uma posição vaga na grade Este algoritmo é bem eficiente para o caso 9x9, mas para o caso 16x16 ainda é preciso melhorias. O algoritmo X do Knuth é mais eficiente, mas é um pouco mais complexo. */ #include #define INF 500 using namespace std; /*vetor de palavras com tamanho menor que 32 bits**/ typedef long long lint; typedef unsigned long long ulint; /*Esta estrtura representa um nó no grafo de estados do problema*/ struct V{ //tam_word=9 NMAX=20; //n_words=64/9 numero de palavras por chunck int n_words, nbits, MASK; ulint v[6]; ulint mask; V(int n_words=5,int nbits=10, int MASK=1023) :n_words(n_words),nbits(nbits),mask(MASK){ for(int i=0;i<6;i++) v[i]=0; } V(const V& b){ n_words=b.n_words; nbits=b.nbits; MASK=b.MASK; mask=b.mask; for(int i=0;i<6;i++) v[i]=b.v[i]; } inline void insert(int p, ulint V){ int i; i=p/n_words; p=p%n_words; p*=nbits; v[i]=(v[i]^(v[i] & (mask<>p)&mask); } V& operator=(const V& b){ n_words=b.n_words; nbits=b.nbits; MASK=b.MASK; mask=b.mask; for(int i=0;i<6;i++) v[i]=b.v[i]; return *this; } }; /****************************/ //Armazena estado anterior struct st{ V s, pl, pc, ps;//estado anterior int le, x, y;//ultima escolha e posicao onde ocorreu st():s(16,4,15),pl(),pc(),ps(),le(1),x(0),y(0){} st(const V& s, const V& pl, const V& pc, const V& ps, int le=1, int x=0, int y=0) :s(s),pl(pl),pc(pc),ps(ps),le(le),x(x),y(y){} st& operator=(const st& a){ s=a.s; pl=a.pl; pc=a.pc; ps=a.ps; le=a.le; x=a.x; y=a.y; return *this; } }; /*Pilha de estados*/ static st Q[81]; int ip; static int hel[10]; static int lg[1<<10]; static int ones[1<<10]; static const ulint inf=~(0LL); // Imprime solução inline void print(V& sol) { int i, j; for(i=0;i<9;i++){ for(j=0;j<9;j++) printf("%d",sol.get(i*9+j)); printf("\n"); } } /*Função de backtracking que explora a arvore de possibilidades do jogo*/ bool solve(V& s){ V podeLin, podeCol, podeSet; int i, j, x, y, a, b, set; int px, py, mi, l, ns; bool ok; /*Inicializa opções para cada linha coluna e setor*/ for(i=0;i<2;i++) podeCol.v[i]=podeSet.v[i]=podeLin.v[i]=inf; ok=true; ip=0; int np=0; for(;;){ //Verifica se já resolvi o sudoku s //print(s); init: np++; //Caso não foi possível realizar uma jogada na iteração anterior desempilha-se um estado da pilha if(!ok) for(;;){ ip--; /*Se já tentei todas opções da pilha e mesmo assim não resolvi o sudoku, então o sudoku não tem solução*/ if(ip==-1) return false; else{ /*Desempilho um ramo que pode conter uma solução*/ s=Q[ip].s; /*Recupero opções pra linha, coluna e setor*/ podeLin=Q[ip].pl; podeCol=Q[ip].pc; podeSet=Q[ip].ps; /*Posição de referencia utilizada para fazer a busca*/ px=i=Q[ip].x; py=j=Q[ip].y; a=(i/3); b=(j/3); set=a*3+b; y=podeLin.get(i); y&=podeCol.get(j); y&=podeSet.get(set); for(i=Q[ip].le+1;i<10;i++) if((y>>i)&0x1){ /*Empilho opções restantes*/ Q[ip]=st(s,podeLin,podeCol,podeSet,i,px,py); ip++; s.insert(px*9+py,i); goto cont;//Preciso sair desse mais aninhado } } } cont: //Realiza travas e procura posições que tem opcoes unicas ns=0; for(i=0;i<9;i++) for(j=0;j<9;j++){ x=s.get(i*9+j); a=(i/3); b=(j/3); set=a*3+b; if(x>0){ ns++; //Atualiza opções pra linha y=podeLin.get(i); y&=hel[x]; podeLin.insert(i,y); //Atualiza opções pra coluna y=podeCol.get(j); y&=hel[x]; podeCol.insert(j,y); //Atualiza opções pro setor y=podeSet.get(set); y&=hel[x]; podeSet.insert(set,y); } } /*Caso eu já tenha preenchido todas 81 casas, então eu resolvi o sudoku*/ if(ns==81){ print(s); return true; } /* Atualiza opções para cada linha e coluna*/ mi=INF; ok=false; for(i=0;i<9;i++) for(j=0;j<9;j++){ x=s.get(i*9+j); a=(i/3); b=(j/3); set=a*3+b; if(x==0){ y=podeLin.get(i); y&=podeCol.get(j); y&=podeSet.get(set); x=lg[y]; if(x>0){ /*Insere possivel valor pra posição i, j da grade*/ s.insert(i*9+j,x); /*bloqueia x como opção para linha i, coluna j e setor set*/ y=podeLin.get(i); y&=hel[x]; podeLin.insert(i,y); y=podeCol.get(j); y&=hel[x]; podeCol.insert(j,y); y=podeSet.get(set); y&=hel[x]; podeSet.insert(set,y); ok=true; }else if(y==0) goto init; else{ /*opções pra pra posição i, j*/ x=ones[y]; if(x>i)&0x1){ Q[ip]=st(s,podeLin,podeCol,podeSet,i,px,py); ip++; s.insert(px*9+py,i); ok=true; break; } } } } //*********************************************************// //MAIN //*********************************************************// /*Verifica é possivel resolver a grade*/ bool find_error(V& s){ for(int n=1;n<10;n++){ int noc; for(int i=0;i<9;i++){ noc=0; for(int j=0;j<9;j++) if(s.get(i*9+j)==n) noc++; if(noc>1) return false; } for(int i=0;i<9;i++){ noc=0; for(int j=0;j<9;j++) if(s.get(j*9+i)==n) noc++; if(noc>1) return false; } for(int i=0;i<3;i++){ int lm=3*(i+1); int auxI=3*i; for(int j=0;j<3;j++){ int lp=3*(j+1); noc=0; for(int m=auxI;m1) return false; } } } return true; } int main() { int N, x, i, j, len, m,c; V s(16,4,15); len=1<<10; m=len-1; for(i=0;i>j & 0x1)x++; ones[i]=x; } for(i=0;i<10;i++) { lg[1<0) hel[i]--; } c=1; scanf("%d",&N); while(N--){ for(i=0;i<9;i++) for(j=0;j<9;j++){ scanf("%1d",&x); s.insert(i*9+j,x); } if(!find_error(s)) printf("Could not complete this grid.\n"); else if(!solve(s)) printf("Could not complete this grid.\n"); c++; } return 0; } ================================================ FILE: other-languages/ai/sudoku/test_001.in ================================================ 1 103000509 002109400 000704000 300502006 060000050 700803004 000401000 009205800 804000107 ================================================ FILE: other-languages/array/merge/merge.rb ================================================ =begin Merge Autor: ? Colaborador: José Alberto O. Morais Filho (j.moraisg12@gmail.com) Tipo: array-operations Descrição: Combina dois subvetores (ordernados), gerando um vetor ordenado Complexidade: O(n) Dificuldade: médio Referências: [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 29-34) =end def merge(array, left, mid, right) n1 = mid - left + 1 n2 = right - mid l = Array.new(n1 + 1) {0} r = Array.new(n2 + 1) {0} for i in 0...n1 do l[i] = array[left + i] end for j in 1..n2 do r[j - 1] = array[mid + j] end l[n1] = 999999 r[n2] = 999999 i = 0 j = 0 for k in left..right do if l[i] <= r[j] array[k] = l[i] i += 1 else array[k] = r[j] j += 1 end end end # Exemplos a = [5, 6, 7, 8, 9, 1, 2, 3, 4] merge(a, 0, 4, 8) print a puts b = [1, 3, 5, 7, 2, 4, 6, 8] merge(b, 0, 3, 7) print b = right - mid l = Array.new(n1 + 1) {0} r = Array.new(n2 + 1) {0} for i in 0...n1 do ================================================ FILE: other-languages/array/partition/partition.rb ================================================ =begin Partition Autor: ? Colaborador: José Alberto O. Morais Filho (j.moraisg12@gmail.com) Tipo: array-operations Descrição: Reposiciona os valores de um array de tal forma que todos os elementos da esquerda do pivô (ultimo elemento) sejam menores que ele e os da direita sejam maiores. Complexidade: O(n) Dificuldade: médio Referências: [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 171-172) =end # Entrada: # array = um vetor a ser reposicionado; # left = primeira posição do vetor (ou subvetor); # right = última posição do vetor (ou subvetor); # Saída: # A posição do pivô no novo vetor def partition(array, left, right) x = array[right] i = left - 1 for j in left...right do if array[j] <= x then i += 1 array[i], array[j] = array[j], array[i] end end array[i + 1], array[right] = array[right], array[i + 1] i + 1 end # Exemplos a = [2, 8, 7, 1, 3, 5, 6, 4] b = [3, 1, 2, 6, 7, 4, 5] print(partition a, 0, 7) puts print(partition b, 0, 6)or (ou subvetor); # right = última posição do vetor (ou subvetor); # Saída: # A posição do pivô no novo vetor def partition(array, left, right) x = array[right] i = left - 1 for j in left...right do if array[j] <= x then i += 1 array[i], array[j] = array[j], array[i] end end array[i + 1], array[right] = array[right], array[i + 1] i + 1 end # Exemplos a = [2, 8, 7, 1, 3, 5, 6, 4] b = [3, 1, 2, 6, 7, 4, 5] print(partit ================================================ FILE: other-languages/bitwise/BitScanForwardDebruijn64.cs ================================================ //BitScanForward com De Bruijn (64 bits) //Autor: // Juan Lopes //Tipo: // bitwise //Descrio: // Encontra o ndice do LSB (Least Significant Bit) em O(1) //Complexidade: // Pior caso: O(1) // Melhor caso: O(1) //Dificuldade: // facil //Referncias: // http://en.wikipedia.org/wiki/De_Bruijn_sequence using System; namespace BitScanForwardDebruijn64 { class Program { static int[] index64 = new[] { 63, 0, 58, 1, 59, 47, 53, 2, 60, 39, 48, 27, 54, 33, 42, 3, 61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4, 62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21, 56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5 }; public static int BitScanForward(ulong value) { if (value == 0) return -1; const ulong debruijn64 = 0x07EDD5E59A4E28C2ul; return index64[((value & (~value + 1)) * debruijn64) >> 58]; } static void Main(string[] args) { Console.WriteLine(BitScanForward(128)); } } } ================================================ FILE: other-languages/bitwise/HammingWeight64.cs ================================================ //Hamming Weight (64 bits) //Autor: // Juan Lopes //Tipo: // bitwise //Descrio: // Conta o nmero de bits ligados // em um inteiro de 64 bits. //Complexidade: // Pior caso: O(1) // Melhor caso: O(1) //Dificuldade: // facil //Referncias: // http://en.wikipedia.org/wiki/Hamming_weight using System; namespace HammingWeight64 { class Program { public static int PopCount(ulong x) { unchecked { const ulong h01 = 0x0101010101010101; const ulong m1 = 0x5555555555555555; const ulong m2 = 0x3333333333333333; const ulong m4 = 0x0f0f0f0f0f0f0f0f; x -= (x >> 1) & m1; x = (x & m2) + ((x >> 2) & m2); x = (x + (x >> 4)) & m4; return (int)((x * h01) >> 56); } } static void Main(string[] args) { Console.WriteLine(PopCount(128)); } } } ================================================ FILE: other-languages/bitwise/bsf-debruijn/BitScanForwardDebruijn64.cs ================================================ //BitScanForward com De Bruijn (64 bits) //Autor: // Nicolaas Govert de Bruijn //Tipo: // bitwise //Descrio: // Encontra o ndice do LSB (Least Significant Bit) em O(1) //Complexidade: // O(1) //Dificuldade: // facil //Referncias: // http://en.wikipedia.org/wiki/De_Bruijn_sequence using System; namespace BitScanForwardDebruijn64 { class Program { static int[] index64 = new[] { 63, 0, 58, 1, 59, 47, 53, 2, 60, 39, 48, 27, 54, 33, 42, 3, 61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4, 62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21, 56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5 }; public static int BitScanForward(ulong value) { if (value == 0) return -1; const ulong debruijn64 = 0x07EDD5E59A4E28C2ul; return index64[((value & (~value + 1)) * debruijn64) >> 58]; } static void Main(string[] args) { Console.WriteLine(BitScanForward(128)); } } } ================================================ FILE: other-languages/bitwise/dec2hex/dec2hex.c ================================================ /* Conversor Decimal/Hexadecimal Autor: ? Colaborador: Ramon Caldeira Faria (ramoncaldeira_328@hotmail.com) Tipo: bitwise Descrição: O algoritmo devolve uma string da representação hexadecimal de um determinado inteiro de 8 bits. Complexidade: O(1) Dificuldade: medio */ #include const char* HEXA = "0123456789ABCDEF"; /* @param dec número no intervalo [0,255] */ char* decToHex(unsigned dec) { char* hexadecimal = (char*) calloc(3, sizeof(char)); hexadecimal[0] = HEXA[ (dec & 0xF0) >> 4 ]; hexadecimal[1] = HEXA[ dec & 0x0F ]; hexadecimal[2] = '\0'; return hexadecimal; } ================================================ FILE: other-languages/bitwise/hamming-weight/HammingWeight64.cs ================================================ //Hamming Weight (64 bits) //Autor: // ? //Tipo: // bitwise //Descrio: // Conta o nmero de bits ligados // em um inteiro de 64 bits. //Complexidade: // O(1) //Dificuldade: // facil //Referncias: // http://en.wikipedia.org/wiki/Hamming_weight using System; namespace HammingWeight64 { class Program { public static int PopCount(ulong x) { unchecked { const ulong h01 = 0x0101010101010101; const ulong m1 = 0x5555555555555555; const ulong m2 = 0x3333333333333333; const ulong m4 = 0x0f0f0f0f0f0f0f0f; x -= (x >> 1) & m1; x = (x & m2) + ((x >> 2) & m2); x = (x + (x >> 4)) & m4; return (int)((x * h01) >> 56); } } static void Main(string[] args) { Console.WriteLine(PopCount(128)); } } } ================================================ FILE: other-languages/bitwise/operations/operations.cpp ================================================ /* Operações bitwise Autor: ? Colaborador: Ramon Caldeira (ramoncaldeira_328@hotmail.com) Tipo: bitwise Descrição: Coletânea de algotitmos bitwise. Complexidade: O(1) Dificuldade: fácil */ /* verifica se um número é par */ bool isOdd(int num) { return num & 1; } /* verifica se um número é potência de 2 ex: 16 = 10000(2) 15 = 01111(2) => 16 & 15 = 10000 & 01111 = 0 */ bool isPower2(int num) { return !(num-1 & num); } /* permuta case de caractere funcionamento: na tabela ASCII os caracteres minúsculos se diferenciam dos maiúsculos através do 5° bit = 32 = 20(H) ex: A(65) a(97) a - A = 32 */ void toggleCase(char& ch) { ch ^= 0x20; } /* seta case maiúsculo */ void toUpper(char& ch) { ch &= ~0x20; } /* seta case minúsculo */ void toLower(char& ch) { ch |= 0x20; } ================================================ FILE: other-languages/bitwise/swap_xor/swap_xor.c ================================================ /* Algoritimo de troca de variveis Autor: ? Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: bitwise Descrio: Algoritimo que tem objetivo de trocar os valores de duas variveis sem o uso de uma varivel temporria usando apenas o operdador boolean "ou exclusivo". Lembrando que esse algortimo s funciona se as variveis tiverem em locais diferentes na memria Complexidade: O(1) Dificuldade: fcil Referncias: http://en.wikipedia.org/wiki/XOR_swap_algorithm */ #include void swap(int* a, int* b) { *a = *a ^ *b; *b = *a ^ *b; *a = *a ^ *b; } int main(int argc, char* argv[]) { int var1 = 22; int var2 = 4; printf("Valores antes da troca: var1=%d var2=%d\n", var1, var2); swap(&var1, &var2); printf("Valores depois da troca: var1=%d var2=%d\n", var1, var2); return 0; } ================================================ FILE: other-languages/bitwise/swap_xor/swap_xor.cs ================================================ /* Algoritimo de troca de variveis Autor: ? Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: bitwise Descrio: Algoritimo que tem objetivo de trocar os valores de duas variveis sem o uso de uma varivel temporria usando apenas o operdador boolean "ou exclusivo". Lembrando que esse algortimo s funciona se as variveis tiverem em locais diferentes na memria Complexidade: O(1) Dificuldade: fcil Referncias: http://en.wikipedia.org/wiki/XOR_swap_algorithm */ using System; public sealed class SwapXor { public static void swap(ref int a, ref int b) { a = a ^ b; b = a ^ b; a = a ^ b; } public static void Main() { int var1 = 1234; int var2 = 5678; Console.WriteLine("Valores antes da troca: var1 = {0} var2 = {1}", var1, var2); SwapXor.swap(ref var1, ref var2); Console.WriteLine("Valores depois da troca: var1 = {0} var2 = {1}", var1, var2); } } ================================================ FILE: other-languages/bitwise/swap_xor/swap_xor.php ================================================ "; swap($var1, $var2); echo "Valores despois da troca: \$var1=$var1 \$var2=$var2
"; ?> ================================================ FILE: other-languages/date/leap-year/leap-year.lisp ================================================ #| Bissexto Autor: ? Colaborador Daniel Valio Tipo: date Complexidade: O(1) Dificuldade: Facil |# (defun ano-bissexto-p (&optional (ano (nth-value 5 (get-decoded-time)))) (and (= (mod ano 4) 0) (or (/= (mod ano 100) 0) (= (mod ano 400) 0)))) ================================================ FILE: other-languages/date/leap-year/leap-year.php ================================================ Tipo: date Descrição: Calcula os próximos anos bissextos Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Ano_bissexto#Calend.C3.A1rio_Gregoriano */ function bissexto($numAnos = 4) { $anoAtual = $anoFinal = date('Y'); $anoFinal += $numAnos; $anos = array(); for ($i = $anoAtual; $i <= $anoFinal; $i++) { if ($i % 4 == 0 and ($i % 100 or $i % 400 == 0)) { $anos[] = $i; } } return $anos; } $proxAnosBissexto = bissexto(100); echo join(', ', $proxAnosBissexto); ================================================ FILE: other-languages/date/leap-year/leap-year.rb ================================================ =begin Bissexto Autor: ? Colaborador: Bruno Lara Tavares Tipo: date Descrição: Calcula os próximos anos bissextos Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Ano_bissexto#Calend.C3.A1rio_Gregoriano =end def anoBissexto(anos) anoAtual = Time.now.year proximoAno = anoAtual + anos bissextos = [] (anoAtual..proximoAno).each do |ano| if (ano%4 == 0) && (ano % 100 != 0 || ano % 400 == 0) bissextos << ano end end bissextos end puts anoBissexto(100) ================================================ FILE: other-languages/economics/financiamento/financiamento.cs ================================================ /* Financiamento Autor: ? Colaborador: Bruno Lara Tavares Tipo: ? Descrição: Calcula o valor das parcelas do financiamneto baseado no capital inicial e taxa de juros de acordo na função Price Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Tabela_price#C.C3.A1lculo */ using System; namespace financiamneto { class MainClass { static public double financiamneto(double investimento, double juros, int periodo) { return (investimento*juros) / (1 - (1/Math.pow((1+juros),periodo)); } public static void Main (string[] args) { Console.WriteLine (financiamneto(1000,0.03,4)); Console.ReadKey(); } } } ================================================ FILE: other-languages/economics/financiamento/financiamento.lisp ================================================ #| Financiamento Autor: ? Colaborador: Daniel Valio Tipo: economics Descricao: Calcula o valor das parcelas do financiamento baseado no capital inicial e taxa de juros de acordo com a funcao Price Complexidade: ? Dificuldade: Facil |# (defun valor-parcela (capital juros periodo) (/ (* capital juros) (- 1 (/ 1 (expt (1+ juros) periodo))))) ================================================ FILE: other-languages/economics/financiamento/financiamento.php ================================================ Colaborador: Felipe Djinn Tipo: econimics Descrição: Calcula o valor das parcelas do financiamneto baseado no capital inicial e taxa de juros de acordo na função Price Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Tabela_price#C.C3.A1lculo */ function financiamento($investimento, $juros, $periodo) { return ($investimento * $juros) / (1 - (1 / pow((1 + $juros), $periodo))); } echo financiamento(1000, 0.03, 4), "\n"; ================================================ FILE: other-languages/economics/financiamento/financiamento.rb ================================================ # -*- encoding: utf-8 -*- =begin Financiamento Autor: ? Colaborador: Bruno Lara Tavares Tipo: ? Descrição: Calcula o valor das parcelas do financiamneto baseado no capital inicial e taxa de juros de acordo na função Price Complexidade: ? Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Tabela_price#C.C3.A1lculo =end def parcelas(investimento, juros, periodo) (investimento*juros) / (1 - (1/(1+juros)**periodo)) end puts parcelas(1000, 0.03, 4) ================================================ FILE: other-languages/economics/juros-compostos/juros-compostos.lisp ================================================ #| Calculo de juros compostos Autor: ? Colaborador: Daniel Valio Tipo: economics Descricao: Varias formas de se calcular varias modalidades de juros compostos. Complexidade: O(1) Dificulade: Facil |# ;;;; Nota: os juros sao colocados em fracoes decimais, ;;;; e nao porcentagens. (defun juros-compostos-continuos (capital juros tempo) (* capital (exp (* juros tempo)))) ================================================ FILE: other-languages/geography/haversine/haversine.rb ================================================ # -*- encoding: utf-8 -*- =begin Haversine Autor: ? Colaborador: Bruno Lara Tavares Tipo: geography Descrição: Calcula a distancia mais curta entre dois pontos com latitude e longitude na superficie da Terra usando a formula de haversine Complexidade: ? Dificuldade: medio Referências: http://en.wikipedia.org/wiki/Haversine_formula =end class String def Todegree grau, minuto, segundo = self.split().collect {|i| i.to_f} if(self.include? "-") grau -= (minuto/60) + (segundo/3600) else grau += (minuto/60) + (segundo/3600) end end end class Numeric def degrees self * Math::PI / 180.0 end end def haversin(theta) Math.sin(theta/2)**2 end Radius = 6371 def distancia(latitude1, longitude1, latitude2, longitude2) deltaLatitude = (latitude2 - latitude1).degrees deltaLongitude = (longitude2 - longitude1).degrees h = haversin(deltaLatitude) + Math.cos(latitude1.degrees)*Math.cos(latitude2.degrees )*haversin(deltaLongitude) 2*Radius*Math.asin(Math.sqrt(h)) end puts distancia("53 08 50".Todegree,"-01 50 58".Todegree,"52 12 16".Todegree,"00 08 26".Todegree) ================================================ FILE: other-languages/graphs/dijkstra/dijkstra.cpp ================================================ /* Algoritmo de Dijkstra (com matriz de adjacências) Autores: Edsger Dijkstra Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Alteração: Péricles Lopes Machado (pericles.raskolnikoff@gmail.com) Tipo: graphs Descrição: O Algoritmo de Dijsktra é um algoritmo em grafos clássico que determina a menor distância de um determinado vértice para todos os outros. Essa é a implementação utilizando matriz de adjacências, que tem desempenho inferior. Complexidade: O(|E| log |V|) Dificuldade: medio Referências: [1] http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm [2] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. ISBN 978-0-262-53305-8. Páginas 658-659. */ #include #include #include #include using namespace std; /* Parâmetros: dist: a matriz de adjacências contendo as distâncias entre os vértices */ const int n = 5; const int INFINITY = (1 << 30)-1; // 2^30-1 /* Parâmetros: dist: matriz de adjacências que contém as distâncias entre os vértices origin: o vértice a partir do qual serão calculadas as menores distâncias min_dist: vetor para armazenar as menores distâncias calculadas com o algoritmo previous: vetor para armazenar o vértice anterior para chegar ao vértice atual (permite determinar as rotas). */ void dijkstra(int dist[n][n], int origin, int min_dist[n], int previous[n]) { // define a lista de adjascencias que é uma representação melhor // para o algoritmo de Dijkstra. Lembrando que representação é // uma parte importante na construção de um algoritmo eficiente typedef vector > Graph; Graph G(n); // inicializa (todas as menores distâncias como infinito) for (int i = 0; i < n; i++) { min_dist[i] = INFINITY; previous[i] = -1; // cria a lista de adjascências for (int j = 0; j < n; ++j) if (i != j and dist[i][j] < INFINITY) { G[i].push_back(j); } } // exceto a da origem para a origem, que é 0 min_dist[origin] = 0; // heap utilizada para acelerar a busca pelo melhor opção atual typedef pair Pair; priority_queue Q; // a distancia atual para a origin é utilizada como primeira chave para a ordenação da heap Q.push(Pair(0, origin)); while (!Q.empty()) { int u = Q.top().second; Q.pop(); for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; if (min_dist[u] + dist[u][v] < min_dist[i]) { min_dist[v] = min_dist[u] + dist[u][v]; previous[v] = u; // como a priority_queue utiliza a chave de mais alta prioridade para ordenar // basta multiplar por -1 a estimativa atual para ordenar adequadamente a heap Q.push(Pair(-min_dist[v], v)); } } } } void print_path(int previous[], int n) { if ( previous[n] != -1 ) { print_path(previous, previous[n]); printf("-> %d ", n); } else printf("%d ", n); } int main( ) { // Visualização desse grafo: http://i52.tinypic.com/2qx6z2p.png // Distâncias INFINITY indicam que não há aresta que ligue os dois vértices int dist[n][n] = { {0, 10, INFINITY, 5, INFINITY}, {INFINITY, 0, 1, 2, INFINITY}, {INFINITY, INFINITY, 0, INFINITY, 4}, {INFINITY, 3, 9, 0, 2}, {2, INFINITY, 6, INFINITY, 0}}; int min_dist[n], prev[n]; dijkstra(dist, 0, min_dist, prev); for (int i = 1; i < n; i++) { printf("Shortest path from 0 to %d: ", i); print_path(prev, i); printf(". Distance: %d\n", min_dist[i]); } return 0; } ================================================ FILE: other-languages/graphs/dijkstra/dijkstra.java ================================================ /* Algoritmo de Dijkstra Autor: Esdger Dijkstra Colaborador: Filipe Saraiva (filip.saraiva@gmail.com) Tipo: graph Descrição: O Algoritmo de Dijsktra é um algoritmo em grafos clássico que determina a menor distância de um determinado vértice para todos os outros. Complexidade: O(n²) Dificuldade: medio Referências: [1] http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm [2] http://pt.wikipedia.org/wiki/Algoritmo_de_Dijkstra [3] http://www-b2.is.tokushima-u.ac.jp/~ikeda/suuri/dijkstra/Dijkstra.shtml Licenca: GPLv3 */ import java.util.ArrayList; public class dijkstra { /** * Implementação do Algoritmo de Dijkstra */ public static int [][] dijkstra(int [][] matrizSistema){ /** * ArrayList para guardar os vértices já verificados pelo Algoritmo de Dijkstra */ ArrayList verticesVerificados = new ArrayList(); /** * ArrayList para guardar as distâncias relativas para cada vértice em cada * iteração do Algoritmo de Dijkstra */ ArrayList distanciaRelativa = new ArrayList(); /** * ArrayList unidimensional que guarda os nós vizinhos de cada nó do grafo * da árvore final produzida pelo Algoritmo de Dijkstra */ ArrayList nosVizinhos = new ArrayList(); /** * Inicialização de variáveis */ for(Integer contador = 0; contador < matrizSistema[0].length; contador++){ verticesVerificados.add(false); nosVizinhos.add(0); distanciaRelativa.add(Integer.MAX_VALUE); } distanciaRelativa.set(0, new Integer(0)); /** * Definição do ponto que será a raiz da árvore resultante */ Integer pontoAvaliado = 0; /** * Estrutura para execução das iterações do Algoritmo de Dijkstra */ for(Integer contadorPontosAvaliados = 0; contadorPontosAvaliados < matrizSistema[0].length; contadorPontosAvaliados++){ for(Integer contadorVizinhos = 0; contadorVizinhos < matrizSistema[0].length; contadorVizinhos++){ /** * Verifica se o nó a ser avaliado nesta iteração já foi avaliado anteriormente; * se sim, passa para a próxima iteração */ if((verticesVerificados.get(contadorVizinhos)) || (contadorVizinhos == pontoAvaliado)){ continue; } /** * Duas comparações aqui: * * 1ª - Verifica se na matrizSistema há algum valor na coluna que seja > 0. Caso afirmativo, * significa que há uma aresta entre estes dois pontos do grafo. * * 2ª - Verifica se a soma do peso da aresta entre os dois nós mais a distanciaRelativa do nó * que serve como pontoAvaliado é menor que a atual distanciaRelativa do nó vizinho. * * Caso correto, a distanciaRelativa do nó vizinho ao que está sendo avaliado no momento será * atualizada pelo valor da distanciaRelativa até o pontoAvaliado + distancia entre o pontoAvaliado * e o nó vizinho. */ if((matrizSistema[pontoAvaliado][contadorVizinhos] > 0) && ((matrizSistema[pontoAvaliado][contadorVizinhos] + distanciaRelativa.get(pontoAvaliado) < distanciaRelativa.get(contadorVizinhos)))){ distanciaRelativa.set(contadorVizinhos, matrizSistema[pontoAvaliado][contadorVizinhos] + distanciaRelativa.get(pontoAvaliado)); nosVizinhos.set(contadorVizinhos, pontoAvaliado); } } /** * Marca o vértice de pontoAvaliado como um vértice já verificado */ verticesVerificados.set(pontoAvaliado, true); /** * Preparação para seleção do próximo vértice a ser avaliado */ pontoAvaliado = new Integer(0); Integer distanciaComparada = new Integer(Integer.MAX_VALUE); /** * Seleção do próximo vértice a ser avaliado */ for(Integer contador = 1; contador < verticesVerificados.size(); contador++){ /** * Se o vertice a ser verificado já foi verificado anteriormente (true) * passa à próxima iteração. */ if(verticesVerificados.get(contador)){ continue; } /** * Se a distância relativa desse ponto for menor que a do ponto avaliado * assume-se esse novo ponto como o ponto avaliado. * * Ao final da iteração, será selecionado o ponto com menor * distância relativa. */ if(distanciaRelativa.get(contador) < distanciaComparada){ distanciaComparada = distanciaRelativa.get(contador); pontoAvaliado = contador; } } } int [][] matrizResposta = new int [matrizSistema[0].length][matrizSistema[0].length]; /** * Criação da matrizResposta com a árvore resultante do Algoritmo de Dijkstra */ for(int contador = 1; contador < nosVizinhos.size(); contador++){ matrizResposta[contador][nosVizinhos.get(contador)] = matrizSistema[contador][nosVizinhos.get(contador)]; matrizResposta[nosVizinhos.get(contador)][contador] = matrizResposta[contador][nosVizinhos.get(contador)]; } return matrizResposta; } /** * Método main para executar o Algoritmo de Dijkstra */ public static void main(String[] args) { /** * Exemplo de grafo - matriz de adjacência onde um número diferente de 0 significa o peso da ligação * entre os nós da matriz * * Você poderá substituir por qualquer matriz quadrada não negativa */ int [][] matrizSistema = {{0, 0, 13, 0, 16, 8}, {0, 0, 0, 6, 0, 10}, {13, 0, 0, 14, 0, 11}, {0, 6, 14, 0, 5, 17}, {16, 0, 0, 5, 0, 7}, {8, 10, 11, 17, 7, 0}}; /** * Chamada do Algoritmo de Dijkstra */ int[][] matrizResultado = dijkstra(matrizSistema); /** * Impressão da matrizResultado com a resposta do Algoritmo de Dijkstra */ for(int contadorHorizontal = 0; contadorHorizontal < matrizResultado[0].length; contadorHorizontal++){ for(int contadorVertical = 0; contadorVertical < matrizResultado[0].length; contadorVertical++){ System.out.print(matrizResultado[contadorHorizontal][contadorVertical] + " "); } System.out.println(); } } } ================================================ FILE: other-languages/graphs/floyd-warshall/floyd-warshall.cpp ================================================ /* Algoritmo de Floyd-Warshall Autores: Robert Floyd e Stephen Warshall Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: graphs Descrição: O Algoritmo de Floyd-Warshall, a partir de uma grafo representado em uma matriz (matriz de adjacências), determina as menores distâncias entre todos os pares (ou seja, as menores distâncias de todos os vértices para todos os vértices). Complexidade: O(|V|³) Dificuldade: medio Referências: [1] http://en.wikipedia.org/wiki/Floyd-Warshall [2] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. ISBN 978-0-262-53305-8. Páginas 693-695. */ #include /* Parâmetros: dist: a matriz de adjacências contendo as distâncias entre os vértices */ const int n = 3; void floyd_warshall(int dist[n][n]) { for (int k = 0; k < n; k++) for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) if ( dist[i][k] + dist[k][j] < dist[i][j] ) dist[i][j] = dist[i][k] + dist[k][j]; } int main( ) { int dist[n][n] = { {0, 3, 10}, {3, 0, 1000}, {10, 1000, 0} }; floyd_warshall(dist); for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) std::cout << "Menor distancia de " << i << " para " << j << ": " << dist[i][j] << "\n"; return 0; } ================================================ FILE: other-languages/graphs/prim/prim.java ================================================ /* Algoritmo de Prim Autor: Vojtěch Jarník(1930) e Robert C. Prim(1957) Colaborador: Filipe Saraiva (filip.saraiva@gmail.com) Tipo: graph Descrição: O Algoritmo de Prim é um algoritmo em grafos clássico que determina a árvore geradora mínima de um grafo conectado não-orientado. Complexidade: O(n²) Dificuldade: medio Referências: [1] http://en.wikipedia.org/wiki/Prim%27s_algorithm [2] http://pt.wikipedia.org/wiki/Algoritmo_de_Prim [3] http://www-b2.is.tokushima-u.ac.jp/~ikeda/suuri/dijkstra/Prim.shtml Licenca: GPLv3 */ import java.util.ArrayList; public class prim { /** * Implementação do Algoritmo de Prim */ public static int [][] prim(int [][] matrizSistema){ /** * ArrayList para guardar os vértices já verificados pelo Algoritmo de Prim */ ArrayList verticesVerificados = new ArrayList(); /** * ArrayList para guardar as distâncias relativas para cada vértice em cada * iteração do Algoritmo de Prim */ ArrayList distanciaRelativa = new ArrayList(); /** * ArrayList unidimensional que guarda os nós vizinhos de cada nó do grafo * da árvore final produzida pelo Algoritmo de Prim */ ArrayList nosVizinhos = new ArrayList(); /** * Inicialização de variáveis */ for(Integer contador = 0; contador < matrizSistema[0].length; contador++){ verticesVerificados.add(false); nosVizinhos.add(0); distanciaRelativa.add(Integer.MAX_VALUE); } distanciaRelativa.set(0, new Integer(0)); /** * Definição do ponto que será a raiz da árvore resultante */ Integer pontoAvaliado = 0; /** * Estrutura para execução das iterações do Algoritmo de Prim */ for(Integer contadorPontosAvaliados = 0; contadorPontosAvaliados < matrizSistema[0].length; contadorPontosAvaliados++){ for(Integer contadorVizinhos = 0; contadorVizinhos < matrizSistema[0].length; contadorVizinhos++){ /** * Verifica se o nó a ser avaliado nesta iteração já foi avaliado anteriormente; * se sim, passa para a próxima iteração */ if((verticesVerificados.get(contadorVizinhos)) || (contadorVizinhos == pontoAvaliado)){ continue; } /** * Duas comparações aqui: * * 1ª - Verifica se na matrizSistema há algum valor na coluna que seja > 0. Caso afirmativo, * significa que há uma aresta entre estes dois pontos do grafo. * * 2ª - Verifica se o peso da aresta entre os dois nós é menor que a atual distanciaRelativa * do nó vizinho. * * Caso correto, a distanciaRelativa do nó vizinho ao que está sendo avaliado no momento será * atualizada pelo valor dessa nova distancia avaliada até o pontoAvaliado. */ if((matrizSistema[pontoAvaliado][contadorVizinhos] > 0) && ((matrizSistema[pontoAvaliado][contadorVizinhos] < distanciaRelativa.get(contadorVizinhos)))){ distanciaRelativa.set(contadorVizinhos, matrizSistema[pontoAvaliado][contadorVizinhos]); nosVizinhos.set(contadorVizinhos, pontoAvaliado); } } /** * Marca o vértice de pontoAvaliado como um vértice já verificado */ verticesVerificados.set(pontoAvaliado, true); /** * Preparação para seleção do próximo vértice a ser avaliado */ pontoAvaliado = new Integer(0); Integer distanciaComparada = new Integer(Integer.MAX_VALUE); /** * Seleção do próximo vértice a ser avaliado */ for(Integer contador = 1; contador < verticesVerificados.size(); contador++){ /** * Se o vertice a ser verificado já foi verificado anteriormente (true) * passa à próxima iteração. */ if(verticesVerificados.get(contador)){ continue; } /** * Se a distância relativa desse ponto for menor que a do ponto avaliado * assume-se esse novo ponto como o ponto avaliado. * * Ao final da iteração, será selecionado o ponto com menor * distância relativa. */ if(distanciaRelativa.get(contador) < distanciaComparada){ distanciaComparada = distanciaRelativa.get(contador); pontoAvaliado = contador; } } } int [][] matrizResposta = new int [matrizSistema[0].length][matrizSistema[0].length]; /** * Criação da matrizResposta com a árvore resultante do Algoritmo de Prim */ for(int contador = 1; contador < nosVizinhos.size(); contador++){ matrizResposta[contador][nosVizinhos.get(contador)] = matrizSistema[contador][nosVizinhos.get(contador)]; matrizResposta[nosVizinhos.get(contador)][contador] = matrizResposta[contador][nosVizinhos.get(contador)]; } return matrizResposta; } /** * Método main para executar o Algoritmo de Prim */ public static void main(String[] args) { /** * Exemplo de grafo - matriz de adjacência onde um número diferente de 0 significa o peso da ligação * entre os nós da matriz * * Você poderá substituir por qualquer matriz quadrada não negativa */ int [][] matrizSistema = {{0, 5, 30, 0, 0, 0}, {5, 0, 20, 10, 0, 0}, {30, 20, 0, 10, 15, 0}, {0, 10, 10, 0, 5, 20}, {0, 0, 15, 5, 0, 15}, {0, 0, 0, 20, 15, 0}}; /** * Chamada do Algoritmo de Prim */ int[][] matrizResultado = prim(matrizSistema); /** * Impressão da matrizResultado com a resposta do Algoritmo de Prim */ for(int contadorHorizontal = 0; contadorHorizontal < matrizResultado[0].length; contadorHorizontal++){ for(int contadorVertical = 0; contadorVertical < matrizResultado[0].length; contadorVertical++){ System.out.print(matrizResultado[contadorHorizontal][contadorVertical] + " "); } System.out.println(); } } } ================================================ FILE: other-languages/lang/nums2words.c ================================================ /* nums2words Autor: ? Colaborador: Stanislaw Pusep Tipo: lang Descrio: Conversor de nmeros inteiros em strings de numerais cardinais em portugus. Exemplo: 9223372036854775807 (maior inteiro positivo de 64 bits) => "nove quinqualhes e duzentos e vinte e trs quatrilhes e trezentos e setenta e dois trilhes e trinta e seis bilhes e oitocentos e cinqenta e quatro milhes e setecentos e setenta e cinco mil e oitocentos e sete" Complexidade: ? Dificuldade: medio Referncias: [1] http://sysd.org/stas/node/20 [2] http://pt.wikipedia.org/wiki/Nomes_dos_n%C3%BAmeros [3] http://pt.wikipedia.org/wiki/Escalas_curta_e_longa */ #include #include #include // tamanhos dos buffers #define MAXRES_S 512 #define MAXTERN_S 64 // formato da estrutura da tabela de transio typedef struct { unsigned int n; char *w; } node; /* * Expande blocos de milhares. * Os nmeros maiores do que mil so "quebrados" em ternas que depois recebem um multiplicador. */ char *ext999 (unsigned int n) { unsigned int i, x, y; char *buf; // mapeamento nmero => nome node rel[] = { {900, "novecentos"}, {800, "oitocentos"}, {700, "setecentos"}, {600, "seiscentos"}, {500, "quinhentos"}, {400, "quatrocentos"}, {300, "trezentos"}, {200, "duzentos"}, {100, "cento"}, {90, "noventa"}, {80, "oitenta"}, {70, "setenta"}, {60, "sessenta"}, {50, "cinquenta"}, {40, "quarenta"}, {30, "trinta"}, {20, "vinte"}, {19, "dezenove"}, {18, "dezoito"}, {17, "dezessete"}, {16, "dezesseis"}, {15, "quinze"}, {14, "quatorze"}, {13, "treze"}, {12, "doze"}, {11, "onze"}, {10, "dez"}, {9, "nove"}, {8, "oito"}, {7, "sete"}, {6, "seis"}, {5, "cinco"}, {4, "quatro"}, {3, "trs"}, {2, "dois"}, {1, "um"}, }; buf = (char *) malloc(MAXTERN_S); buf[0] = '\0'; // casos especiais if (!n) { strcpy(buf, "zero"); return buf; } else if (n == 100) { strcpy(buf, "cem"); return buf; } // faz a reduo do nmero fatorando pelos ndices do mapeamento while (n) { for (i = 0; i < sizeof(rel); i++) { x = rel[i].n; y = n % x; if (x + y == n) { n = y; strcat(buf, rel[i].w); if (n) strcat(buf, " e "); break; } } } return buf; } char *nums2words (long n) { unsigned long x; unsigned int y; int i, j, k; char *res, *p; // mapeamento dos multiplicadores para inteiros 'signed' de 64 bits char *ord[] = { NULL, NULL, "mil", "mil", "milho", "milhes", "bilho", "bilhes", "trilho", "trilhes", "quatrilho", "quatrilhes", "quinqualho", "quinqualhes", }; // array para armazenamento das ternas pr-processadas unsigned int tern[(sizeof(ord) / sizeof(char *)) / 2]; res = (char *) malloc(MAXRES_S); res[0] = '\0'; // trata nmeros negativos if (n < 0) { n *= -1; strcat(res, "menos "); } if (n < 1000) { // nmeros menores do que mil: caso mais simples strcat(res, ext999(n)); } else { // quebra o nmero em ternas x = n; for (j = 0; x; j++) { y = x % 1000; x /= 1000; tern[j] = y; } // obtm string para cada terna e concatenta no resultado for (i = j - 1; i >= 0; i--) { if (y = tern[i]) { // concatena a respectiva terna p = ext999(y); strcat(res, p); free(p); // trata singular ou plural do multiplicador k = i * 2; if (y != 1) k++; // concatena o multiplicador if (p = ord[k]) { strcat(res, " "); strcat(res, p); } // nem sempre o 'e' necessrio; porm desconheo a regra correta :( strcat(res, " e "); } } res[strlen(res) - 3] = '\0'; } return res; } int main (void) { long n; char *p; do { printf("Digite um nmero (0 para sair): "); scanf("%ld", &n); fflush(stdin); p = nums2words(n); printf("voc digitou \"%s\"\n", p); free(p); } while (n); return 0; } ================================================ FILE: other-languages/math/bhaskara/bhaskara.lisp ================================================ #| Formula de Bhaskara Autor: Bhaskara Akaria Colaborador: Daniel Valio Tipo: math Descricao: Calcula as raizes de uma equacao de segundo grau Complexidade: O(1) Dificuldade: facil |# (defun delta-calc (a b c) (- (expt b 2) (* a c 4))) (defun achar-raizes (a b delta) (list (/ (- delta b) (* a 2)) (/ (- (+ delta b)) (* a 2)))) (defun bhaskara (a b c) (unless (< (delta-calc a b c) 0) (achar-raizes a b (delta-calc a b c)))) ================================================ FILE: other-languages/math/bhaskara/bhaskara.php ================================================ ================================================ FILE: other-languages/math/bhaskara/bhaskara.rb ================================================ # encoding: utf-8 =begin Bhaskara Autor: Bhaskara Akaria [1] Colaborador: Bruno Lara Tavares Karlisson Bezerra Tipo: math Descrição: Calcula as raízes de uma equação de segundo grau Complexidade: O(1) DIficuldade: facil Referências: [1] http://pt.wikipedia.org/wiki/Bhaskara_Akaria =end def bhaskara(a, b, c) delta = b ** 2 - 4 * a * c if delta < 0 nil else raizes = [] m1 = Math.sqrt delta r1 =(-b + m1) / (2 * a) raizes.push r1 r2 =(-b - m1) / (2 * a) raizes.push r2 end end puts bhaskara 1, -1, -2 ================================================ FILE: other-languages/math/dda/dda.cpp ================================================ /* DDA (Digital Differential Analyzer) Autor: ? Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: DDA um algoritmo de interpolao linear entre dois pontos, inicial e final. Ele muito usado na rea de Computao Grfica para rasterizar linhas e polgonos. Complexidade: O(n) Dificuldade: facil Referncias: http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf http://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm) */ #include #include #include #include typedef struct Point { public: int x; int y; Point(int x, int y) { this->x = x; this->y = y; } } Point; class DDA { public: static std::list& rasteriza(const Point ini, const Point fim) { std::list* points = new std::list(); //Guardara os pontos criados float len; if (abs(fim.x - ini.x) >= abs(fim.y - ini.y)) { len = abs(fim.x - ini.x); } else { len = abs(fim.y - ini.y); } float deltax = (fim.x - ini.x) / len; float deltay = (fim.y - ini.y) / len; float x = ini.x; float y = ini.y; for (int i = 0; i < len; i++) { points->push_back(Point((int) floor(x), (int) floor(y))); x += deltax; y += deltay; } points->push_back(Point((int) floor(x), (int) floor(y))); return *points; } private: DDA() {} ~DDA() {} }; using namespace std; int main(int argc, char* argv[]) { list points = DDA::rasteriza(Point(-2, 3), Point(10, 15)); list::iterator it; for (it = points.begin(); it != points.end(); it++) { cout << "(" << it->x << ", " << it->y << ")" << endl; } return 0; } ================================================ FILE: other-languages/math/dda/dda.cs ================================================ /* DDA (Digital Differential Analyzer) Autor: ? Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: DDA um algoritmo de interpolao linear entre dois pontos, inicial e final. Ele muito usado na rea de Computao Grfica para rasterizar linhas e polgonos. Complexidade: O(n) Dificuldade: facil Referncias: http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf http://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm) */ using System; using System.Collections.Generic; public struct Point { public int x; public int y; public Point(int x, int y) { this.x = x; this.y = y; } } public static class DDA { public static Point[] rasteriza(Point ini, Point fim) { LinkedList points = new LinkedList(); //Guardara os pontos criados float len; if (Math.Abs(fim.x - ini.x) >= Math.Abs(fim.y - ini.y)) { len = Math.Abs(fim.x - ini.x); } else { len = Math.Abs(fim.y - ini.y); } float deltax = (fim.x - ini.x) / len; float deltay = (fim.y - ini.y) / len; float x = ini.x; float y = ini.y; for (int i = 0; i < len; i++) { points.AddLast(new Point((int) Math.Floor(x), (int) Math.Floor(y))); x += deltax; y += deltay; } points.AddLast(new Point((int) Math.Floor(x), (int) Math.Floor(y))); Point[] ret = new Point[points.Count]; points.CopyTo(ret, 0); return ret; } } public class MainDDA { public static void Main() { Point[] points = DDA.rasteriza(new Point(-2, 3), new Point(10, 15)); foreach (Point point in points) { Console.WriteLine("({0}, {1})", point.x, point.y); } } } ================================================ FILE: other-languages/math/dda/dda.java ================================================ /* DDA (Digital Differential Analyzer) Autor: ? Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: DDA um algoritmo de interpolao linear entre dois pontos, inicial e final. Ele muito usado na rea de Computao Grfica para rasterizar linhas e polgonos. Complexidade: O(n) Dificuldade: facil Referncias: http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf http://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm) */ import java.awt.Point; import java.util.LinkedList; public class dda { public static Point[] rasteriza(Point ini, Point fim) { LinkedList points = new LinkedList(); //Guardara os pontos criados float len; if (Math.abs(fim.x - ini.x) >= Math.abs(fim.y - ini.y)) { len = Math.abs(fim.x - ini.x); } else { len = Math.abs(fim.y - ini.y); } float deltax = (fim.x - ini.x) / len; float deltay = (fim.y - ini.y) / len; float x = ini.x; float y = ini.y; for (int i = 0; i < len; i++) { points.add(new Point((int) Math.floor(x), (int) Math.floor(y))); x += deltax; y += deltay; } points.add(new Point((int) Math.floor(x), (int) Math.floor(y))); return points.toArray(new Point[0]); } public static void main(String[] args) { Point[] points = dda.rasteriza(new Point(-2, 3), new Point(10, 15)); for (Point point : points) { System.out.printf("(%d, %d)\n", point.x, point.y); } } } ================================================ FILE: other-languages/math/dda/dda.php ================================================ x = $x; $this->y = $y; } } class DDA { public static function rasteriza($ini, $fim) { $points = array(); $len; if (abs($fim->x - $ini->x) >= abs($fim->y - $ini->y)) { $len = abs($fim->x - $ini->x); } else { $len = abs($fim->y - $ini->y); } $deltax = ($fim->x - $ini->x) / $len; $deltay = ($fim->y - $ini->y) / $len; $x = $ini->x; $y = $ini->y; for ($i = 0; $i < $len; $i++) { $points[] = new Point(floor($x), floor($y)); $x += $deltax; $y += $deltay; } $points[] = new Point(floor($x), floor($y)); return $points; } } $points = DDA::rasteriza(new Point(-2, 3), new Point(10, 15)); foreach ($points as $point) { echo "($point->x, $point->y)
"; } ?> ================================================ FILE: other-languages/math/dda/dda.rb ================================================ # -*- encoding: utf-8 -*- =begin DDA (Digital Differential Analyzer) Autor: ? Colaborador: Bruno Lara Tavares Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: DDA um algoritmo de interpolao linear entre dois pontos, inicial e final. Ele muito usado na rea de Computao Grfica para rasterizar linhas e polgonos. Complexidade: O(n) Dificuldade: facil Referncias: http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf http://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm) =end def DDA(x1, y1, x2, y2) points = [] #Guardar os pontos criados na forma (x, y) if ((x2 - x1).abs >= (y2 - y1).abs) len = (x2 - x1).abs else len = (y2 - y1).abs end deltax = (x2 - x1).to_f / len deltay = (y2 - y1).to_f / len x = x1.to_f y = y1.to_f (0..len).each do |i| points.push [x.floor, y.floor] x += deltax y += deltay end points.push [x.floor, y.floor] end puts DDA(-1, -1, 12, 9).inspect ================================================ FILE: other-languages/math/determinant/determinant.cpp ================================================ /* Determinante de matriz (utilizando decomposição LU) Autor: Carl Friedrich Gauss Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: math Descrição: É o algoritmo que calcula o determinante de uma matriz utilizando a decomposição LU como base. Como as matrizes L e U são triangulares, o determinante delas são o produto das diagonais. Como o determinante de L é sempre 1, o determinante da matriz original A é igual ao determinante da matriz U. Complexidade: O(n³) Dificuldade: medio Referências: http://en.wikipedia.org/wiki/Lu_decomposition http://en.wikipedia.org/wiki/Determinant http://mathworld.wolfram.com/LUDecomposition.html Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. ISBN 978-0-262-53305-8. Página 821 */ #include #include const int n = 4; void lu_decomposition(float A[n][n], float U[n][n]) { float _A[n][n], L[n][n]; int i, j, k; // copia para evitar modificações na matriz original for (i = 0; i < n; i++) for (j = 0; j < n; j++) _A[i][j] = A[i][j]; // inicializa a matriz U com zeros for (i = 0; i < n; i++) for (j = 0; j < n; j++) U[i][j] = 0; // inicializa a matriz L com 0s acima da diagonal e 1s na diagonal for (i = 0; i < n; i++) for (j = 0; j < n; j++) if ( i < j ) L[i][j] = 0; else if ( i == j ) L[i][j] = 1; for (k = 0; k < n; k++) { U[k][k] = _A[k][k]; for (i = k + 1; i < n; i++) { L[i][k] = _A[i][k]/U[k][k]; U[k][i] = _A[k][i]; } for (i = k + 1; i < n; i++) for (j = k + 1; j < n; j++) _A[i][j] -= L[i][k]*U[k][j]; } } float determinant(float A[n][n]) { float U[n][n]; float result = 1.0f; lu_decomposition(A, U); for (int i = 0; i < n; i++) result *= U[i][i]; return result; } int main( ) { float A[n][n] = { {2.0, 3.0, 1.0, 5.0}, {6.0, 13.0, 5.0, 19.0}, {2.0, 19.0, 10.0, 23.0}, {4.0, 10.0, 11.0, 31.0}}; printf("Determinant: %.2f", determinant(A)); return 0; } ================================================ FILE: other-languages/math/determinant/determinant.rb ================================================ =begin Matrix Determinant Autor: ? Colaborador: José Alberto O. Morais Filho (j.moraisg12@gmail.com) Tipo: math Descrição: Utiliza a decomposição LU para calcular o determinante da matriz. A decomposição LU gera duas matrizes triangulares, de forma que A = L * U -> det(A) = det(L) * det(U). Complexidade: O(n^3) Dificuldade: médio Referências: [1] http://en.wikipedia.org/wiki/LU_decomposition [2] http://en.wikipedia.org/wiki/Determinant =end # Entrada: # a = uma matriz quadrada # Saída: # o determinante dessa matriz def lu_decompose(a) n = a.length for i in 0..n-1 do for j in 0..n-1 do a[i][j] = a[i][j].to_f end end u = Array.new(n) {Array.new(n) {0}} l = Array.new(n) {Array.new(n) {0}} for i in 0..n-1 do for j in 0..n-1 do l[i][i] = 1 if i == j end end for k in 0..n-1 do u[k][k] = a[k][k] for i in k+1..n-1 do l[i][k] = a[i][k] / u[k][k] u[k][i] = a[k][i] end for i in k+1..n-1 do for j in k+1..n-1 do a[i][j] = a[i][j] - l[i][k]*u[k][j] end end end return l, u end def determinant(a) n = a.length l, u = lu_decompose(a) det = 1 for i in 0..n-1 do det *= u[i][i] end det end # Exemplos a = [[1, 3, 2], [9, 5, 4], [8, 6, 7]] b = [[4, 3, 8, 4], [12, 1, 9, 13], [5, 14, 2, 10], [6, 16, 7, 11]] print(determinant a) puts print(determinant b) ================================================ FILE: other-languages/math/divisors/divisor.rb ================================================ # * encoding: UTF-8 * =begin Divisors Autor: ? Colaborador: Bruno Lara Tavares Descricao: Mostra os divisores de um número Complexidade: O(n) Dificuldade: facil =end class Numeric def divisores() a = [] (1..self+1).each do |i| if self % i == 0 a.push i end end a end end puts 12.divisores.inspect ================================================ FILE: other-languages/math/eratostenes/eratostenes.java ================================================ /* Crivo de Eratóstenes Autor: Eratóstenes (285-194 a.C.) Colaborador: Filipe Saraiva (filip.saraiva@gmail.com) Tipo: math Descrição: Dado um número máximo, o Crivo de Eratóstenes encontra todos os números primos de 0 até este número máximo. Complexidade: O(n³) Dificuldade: medio Referências: [1] http://pt.wikipedia.org/wiki/Crivo_de_Erat%C3%B3stenes Licenca: GPLv3 */ import java.util.ArrayList; public class eratostenes { /** * Crivo de Eratóstenes recebe a lista de todos os números de 2 até o número máximo, * e o número máximo a ser verificado */ public static ArrayList eratostenes(ArrayList lista, int numVerificacaoMax){ /** * A posição do primeiro número avaliado na lista é a posição 0 */ int posicaoNumAvaliado = 0; int numAvaliado; /** * Atenção! Aqui é criado um loop infinito proposital. * * O mesmo só será terminado quando a condição dentro dele * for atingida e a instrução *break* for executada. */ while(true){ /** * Busca-se a posição do número que será avaliado */ while(lista.get(posicaoNumAvaliado) == 0){ posicaoNumAvaliado++; } /** * Inicialização do número avaliado */ numAvaliado = lista.get(posicaoNumAvaliado); /** * Verificação dos números múltipos do número avaliado na lista * * Caso o resto da divisão seja igual a 0, o número é múltiplo * Então, o algoritmo substitui o valor do antigo número da lista por 0 */ for(int contador = posicaoNumAvaliado + 1; contador < lista.size(); contador++){ if((lista.get(contador) % numAvaliado) == 0){ lista.set(contador, 0); } } /** * Se o número que acabou de ser avaliado for igual ou maior que * o número máximo a ser verificado, então o algoritmo termina sua execução */ if(lista.get(posicaoNumAvaliado) >= numVerificacaoMax){ break; } /** * Caso o algoritmo não tenha terminado sua execução, incrementa-se posicaoNumAvaliado * para que na próxima iteração se encontre o próximo número a ser avaliado */ posicaoNumAvaliado++; } ArrayList listaPrimos = new ArrayList(); /** * Esta instrução retira os números 0 da lista e coloca-se apenas os * diferentes de 0 na na listaPrimos. Esta lista é o resultado do Crivo * de Eratóstenes */ for(int contador = 0; contador < lista.size(); contador++){ if(lista.get(contador) != 0){ listaPrimos.add(lista.get(contador)); } } return listaPrimos; } /** * Método main para executar o Crivo de Eratóstenes */ public static void main(String[] args) { /** * Lista que guardará os números entre 2 e o número limite máximo * do algoritmo */ ArrayList lista = new ArrayList(); /** * Número limite máximo aleatório. * Altere aqui para encontrar todos os números primos * até ele! */ int numLimiteMax = 120; /** * O número máximo a ser verificado é o piso da raiz quadrada * do número limite máximo. Esta instrução encontra este número */ int numVerificacaoMax = (int) Math.floor(Math.sqrt(numLimiteMax)); /** * Instrução para adicionar os números na lista que vai de 2 (o primeiro número primo) * até o número limite máximo escolhido */ for(int contador = 2; contador <= numLimiteMax; contador++){ lista.add(contador); } /** * Captura do resultado do Crivo de Eratostenes */ ArrayList listaPrimos = eratostenes(lista, numVerificacaoMax); /** * Impressão do resultado do Crivo de Eratostenes */ for (Integer integer : listaPrimos) { System.out.print(integer + " "); } System.out.println(); } } ================================================ FILE: other-languages/math/even/even.c ================================================ /* Encontrando números Pares Autor: ??? Colaboradores: Filipe Saraiva (filip.saraiva@gmail.com) Pedro Arthur Duarte (pedroarthur.jedi@gmail.com) Tipo: math Descrição: Dá-se um número inteiro não negativo; o algoritmo listará todos os números pares entre 0 e este número dado. Complexidade: O(n) Dificuldade: fácil */ #include // Função para imprimir os números pares // entre '0' e um número máximo dado. void numerosPares(int num){ int contador = 0; /* * Maneira convencional: caso o número a ser comparado * tiver o resto da divisão igual a '0', quer dizer quer * o número é um múltiplo de 2 - definição de número par. */ for(contador = 0; contador <= num; contador++){ if((contador % 2) == 0){ printf("%d ", contador); } } /* * Maneira esperta - sabemos que o primeiro número par é igual à 0. * Daí, basta apenas incrementar o contador em mais duas unidades. * Todos os demais números serão pares. * * Descomente a rotina abaixo para a "Maneira esperta". */ // for(contador = 0; contador <= num; contador = contador + 2){ // printf("%d ", contador); // } printf("\n"); } /* Via aritimética binária (maneira convencional) */ void numerosPares_2(int num) { int contador; for (contador = 0 ; contador <= num ; contador++) if ((contador & 1) == 0) printf("%d ", contador); } // Função main int main(){ // Número máximo a ser utilizado. // Troque-o por outro número qualquer. int limite = 13; // Chamada da função numerosPares numerosPares(limite); return 0; } ================================================ FILE: other-languages/math/fatorial/fatorial.cs ================================================ /* Cálculo de fatorial Autor: ? Colaborador: Bruno Lara Tavares Tipo: math Descrição: Calcula o fatorial de um número Complexidade: ? Dificuldade: facil */ using System; namespace fatorial { class MainClass { static public double fatorial(int num) { return num > 1 ?num*fatorial(num-1):1; } public static void Main (string[] args) { Console.Write ("Digite o numero para calcular o fatorial: "); Console.WriteLine (fatorial(int.Parse(Console.ReadLine()))); Console.ReadKey(); } } } ================================================ FILE: other-languages/math/fatorial/fatorial.lisp ================================================ #| Fatorial Autor ? Colaborador Daniel Valio Tipo math Descricao Varias formas diferentes de se calcular um fatorial em Common Lisp. Complexidade (?) Dificuldade Facil |# (defun fatorial-basico (n) ;;; Versao basica e recursiva (if (<= n 1) 1 (* n (fatorial-basico (- n 1))))) (defun fatorial-melhorado (n &optional (acc 1)) ;;; Versao recursiva e (algo) otimizada (if (<= n 1) acc (fatorial-melhorado (- n 1) (* acc n)))) ================================================ FILE: other-languages/math/fatorial/fatorial.php ================================================ Tipo: math Descrição: Calcula o fatorial de um número Complexidade: ? Dificuldade: facil */ function fatorial($b) { return $b <= 1 ? 1 : $b*fatorial($b-1); } echo fatorial(6); ?> ================================================ FILE: other-languages/math/fatorial/fatorial.rb ================================================ # -*- encoding: utf-8 -*- """ Cálculo de fatorial Autor: ? Colaborador: Bruno Lara Tavares Tipo: math Descrição: Calcula o fatorial de um número Complexidade: ? Dificuldade: facil """ def fatorial(b) b <= 1 ? 1 : b*fatorial(b-1) end puts fatorial(6) ================================================ FILE: other-languages/math/fibonacci/fibonacci.c ================================================ /* Fibonacci recursivo e iterativo Autor: Fibonacci Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: Algoritmo usado para gerar a sequncia de Fibonacci. Um termo a soma de seus 2 antecessores. Sendo os primeiros dois termos com valores 0 e 1 respectivamente. 0, 1, 2, 3, 5, 8, 13, ... Complexidade: O(n) Dificuldade: facil */ #include unsigned int fibonacci_recursivo(unsigned int nTermo) { if (nTermo == 1) { return 0; } else if (nTermo == 2) { return 1; } return fibonacci_recursivo(nTermo - 1) + fibonacci_recursivo(nTermo - 2); } unsigned int fibonacci_iterativo(unsigned int nTermo) { unsigned int ante1 = 0; //Antecessor mais longe unsigned int ante2 = 1; //Antecessor mais perto int i; //Varivel de controle if (nTermo == 1) { return 0; } else if (nTermo == 2) { return 1; } for (i = 3; i <= nTermo; i++) { unsigned int tmp = ante2; ante2 = ante1 + ante2; ante1 = tmp; } return ante2; } //Nmero de termos que sero gerados pelas funes #define NTERMOS 22 int main(int argc, char* argv[]) { int i; for (i = 1; i <= NTERMOS; i++) { printf("%d ", fibonacci_recursivo(i)); } putchar('\n'); for (i = 1; i <= NTERMOS; i++) { printf("%d ", fibonacci_iterativo(i)); } return 0; } ================================================ FILE: other-languages/math/fibonacci/fibonacci.clj ================================================ (comment Cálculo da sequência de Fibonacci Autor ? Colaborador Guilherme Victal (guilhermevictal em gmail.com) Tipo math Descrição Cálculo do n-ésimo valor da sequência de fibonacci recursivamente, a partir da definição [a[n]=a[n-1] + a[n-2], a[0]=a[1]=1] Na prática é muito lento mesmo para n não muito grande; Complexidade ? Dificuldade facil ) (defn fibonacci [n] (if (< n 2) 1 (+ (fibonacci (- n 1)) (fibonacci (- n 2))))) (println (map fibonacci (range 1 20))) ================================================ FILE: other-languages/math/fibonacci/fibonacci.cs ================================================ /* Fibonacci recursivo e iterativo Autor: Fibonacci Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: Algoritmo usado para gerar a sequncia de Fibonacci. Um termo a soma de seus 2 antecessores. Sendo os primeiros dois termos com valores 0 e 1 respectivamente. 0, 1, 2, 3, 5, 8, 13, ... Complexidade: O(n) Dificuldade: facil */ using System; public class Fibonacci { public static uint fibonacci_recursivo(uint ntermo) { if (ntermo == 0) { throw new Exception("Term position must be greater than 0"); } else if (ntermo == 1) { return 0; } else if (ntermo == 2) { return 1; } return fibonacci_recursivo(ntermo - 1) + fibonacci_recursivo(ntermo - 2); } public static uint fibonacci_iterativo(uint ntermo) { if (ntermo == 0) { throw new Exception("Term position must be greater than 0"); } else if (ntermo == 1) { return 0; } else if (ntermo == 2) { return 1; } uint ante1 = 0; uint ante2 = 1; for (int i = 3; i <= ntermo; i++) { uint tmp = ante2; ante2 = ante1 + ante2; ante1 = tmp; } return ante2; } public static void Main() { for (uint i = 1; i < 15; i++) { Console.Write(Fibonacci.fibonacci_recursivo(i) + " "); } Console.WriteLine(); for (uint i = 1; i < 15; i++) { Console.Write(Fibonacci.fibonacci_iterativo(i) + " "); } } } ================================================ FILE: other-languages/math/fibonacci/fibonacci.java ================================================ /* Fibonacci recursivo e iterativo Autor: Fibonacci Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: Algoritmo usado para gerar a sequncia de Fibonacci. Um termo a soma de seus 2 antecessores. Sendo os primeiros dois termos com valores 0 e 1 respectivamente. 0, 1, 2, 3, 5, 8, 13, ... Complexidade: O(n) Dificuldade: facil */ public class fibonacci { public static int fibonacci_recursivo(int ntermo) { if (ntermo < 0) { throw new IllegalArgumentException("Term position must be greater than 0"); } else if (ntermo == 1) { return 0; } else if (ntermo == 2) { return 1; } return fibonacci_recursivo(ntermo - 1) + fibonacci_recursivo(ntermo - 2); } public static int fibonacci_iterativo(int ntermo) { if (ntermo < 0) { throw new IllegalArgumentException("Term position must be greater than 0"); } else if (ntermo == 1) { return 0; } else if (ntermo == 2) { return 1; } int ante1 = 0; int ante2 = 1; for (int i = 3; i <= ntermo; i++) { int tmp = ante2; ante2 = ante1 + ante2; ante1 = tmp; } return ante2; } public static void main(String[] args) { for (int i = 1; i < 15; i++) { System.out.print(fibonacci.fibonacci_recursivo(i) + " "); } System.out.println(); for (int i = 1; i < 15; i++) { System.out.print(fibonacci.fibonacci_iterativo(i) + " "); } } } ================================================ FILE: other-languages/math/fibonacci/fibonacci.lisp ================================================ #| Calculo da sequencia de Fibonacci Autor ? Colaborador Daniel Valio Tipo math Descricao Calculo de Fn aonde F e' a sequencia de Fibonacci. Note-se que, apesar de ser quase o mesmo co'digo da versao em Clojure, esta e' muito mais ra'pida, pois em Common Lisp ha' TCO (Tail Call Optimization). Complexidade ? Dificuldade Facil |# (defun fibonacci (n) (if (< n 2) 1 (+ (fibonacci (- n 1)) (fibonacci (- n 2))))) ================================================ FILE: other-languages/math/fibonacci/fibonacci.lua ================================================ --[[ Fibonacci recursivo e iterativo Autor: Fibonacci Colaborador: Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com) Tipo: math Descrio: Algoritmo usado para gerar a sequncia de Fibonacci. Um termo a soma de seus 2 antecessores. Sendo os primeiros dois termos com valores 0 e 1 respectivamente. 0, 1, 2, 3, 5, 8, 13, ... Complexidade: O(n) Dificuldade: facil ]]-- function fibonacci_recursivo(ntermos) if (ntermos < 1) then return; elseif (ntermos == 1) then return 0; elseif (ntermos == 2) then return 1; end return fibonacci_recursivo(ntermos - 1) + fibonacci_recursivo(ntermos - 2); end function fibonacci_iterativo(ntermos) if (ntermos < 1) then return; elseif (ntermos == 1) then return 0; elseif (ntermos == 2) then return 1; end local ante1, ante2, i = 0, 1, 3; while (i <= ntermos) do ante1, ante2 = ante2, ante1 + ante2; i = i + 1; end return ante2; end j = 1; while (j <= 15) do io.write(fibonacci_recursivo(j) .. " "); j = j + 1; end print(""); j = 1; while (j <= 15) do io.write(fibonacci_iterativo(j) .. " "); j = j + 1; end ================================================ FILE: other-languages/math/fibonacci/fibonacci.php ================================================ * Tipo: * math * Descrição: * Na matemática, os Números de Fibonacci são uma sequência definida como recursiva. * O algoritmo recursivo que define a série aplica-se, na prática, conforme a regra sugere: * começa-se a série com 0 e 1; a seguir, obtém-se o próximo número de Fibonacci somando-se * os dois anteriores e, assim, sucessiva e infinitamente. * Complexidade: * F(n) = { * 0 se n = 0; * 1 se n = 1; * F(n - 1) + F(n - 2) * } * Referências: * http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci */ function fibonacci($n) { if ( $n < 2 ) return $n; return fibonacci($n - 1) + fibonacci($n - 2); } // example for ( $i = 0; $i <= 20; $i++ ) { echo fibonacci($i), ' '; } echo "\n"; ================================================ FILE: other-languages/math/fibonacci/fibonacci.rb ================================================ # -*- encoding: utf-8 -*- =begin * Sequência de Fibonacci * * Autor: * Felipe Djinn * Colaborador: * Bruno Lara Tavares * Tipo: * math * Descrição: * Na matemática, os Números de Fibonacci são uma sequência definida como recursiva. * O algoritmo recursivo que define a série aplica-se, na prática, conforme a regra sugere: * começa-se a série com 0 e 1; a seguir, obtém-se o próximo número de Fibonacci somando-se * os dois anteriores e, assim, sucessiva e infinitamente. * Complexidade: * F(n) = { * 0 se n = 0; * 1 se n = 1; * F(n - 1) + F(n - 2) * } * Referências: * http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci * =end class Numeric def fibonacci if (self < 2) self else (self - 1).fibonacci + (self -2).fibonacci end end end (0..20).each do |nesimo| puts nesimo.fibonacci end ================================================ FILE: other-languages/math/gauss/sumgauss.cpp ================================================ /* Soma de Gauus - Gauss Sum Autores: Carl Friedrich Gauss Colaborador: Kaio Turubia (kaiokot@gmail.com) Tipo: math Descrição: É um algoritmo que, dado um número, é a realizada a soma de 1 até o número informado. Ex: Soma de 1 a 100: S = 1+2+3+...+99+100 = 5050 Ex: Soma de 1 a 100: S = 1+2+3+...+99+100 = 5050 Complexidade: ? Dificuldade: facil Referências: [1] http://pt.wikipedia.org/wiki/Soma_de_Gauss */ #include int gaussSum(int number) { int result; result = number * (number + 1) / 2; return (result); } int main () { int number = 100; int result; result = gaussSum(number); std::cout << "The sum value is : " << result; return 0; } ================================================ FILE: other-languages/math/geometric-mean/geometric-mean.cpp ================================================ /* Média geométrica Autor: ? Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: math Descrição: É um algoritmo simples para calcular a média geométrica de n números reais utilizando o método de média de logaritmos (que é mais numericamente estável e computacionalmente mais eficiente que multiplicar todos os números e tirar a raiz, além de evitar o problema de overflow). Complexidade de tempo: O(n) Dificuldade: facil Referências: http://en.wikipedia.org/wiki/Geometric_mean http://en.wikipedia.org/wiki/Numeric_stability */ #include #include double geometric_mean(double values[], int n) { double sum = 0.0; for (int i = 0; i < n; i++) sum += log(values[i]); sum /= n; return exp(sum); } int main( ) { double values[] = {1, 2, 3, 4, 5}; printf("%.10f\n", geometric_mean(values, 5)); return 0; } ================================================ FILE: other-languages/math/linear-system/linear-system.c ================================================ /* Algoritmo para Escalonar Sistemas Lineares Autor: ? Colaborador: ? Tipo: math Descrição: Esta função recebe uma matriz m, n por n, e uma matriz R n por 1. Ela escalona o sistema mX = R, e atribui a R as soluções do sistema. Retorna 1, caso tenha sucesso no escalonamento, ou 0 caso contrário. Complexidade: O(n^2), sendo n a dimensão do sistema. Dificuldade: medio */ int escalonaSistemaLinear(double **m, int n, double R[]){ int i, j, k; for(i=0;i=i;k--){ m[i][k]/=m[i][i]; for(j=0;j #include const int n = 4; void lu_decomposition(float A[n][n], float L[n][n], float U[n][n]) { float _A[n][n]; int i, j, k; // copia para evitar modificações na matriz original for (i = 0; i < n; i++) for (j = 0; j < n; j++) _A[i][j] = A[i][j]; // inicializa a matriz U com zeros for (i = 0; i < n; i++) for (j = 0; j < n; j++) U[i][j] = 0; // inicializa a matriz L com 0s acima da diagonal e 1s na diagonal for (i = 0; i < n; i++) for (j = 0; j < n; j++) if ( i < j ) L[i][j] = 0; else if ( i == j ) L[i][j] = 1; for (k = 0; k < n; k++) { U[k][k] = _A[k][k]; for (i = k + 1; i < n; i++) { L[i][k] = _A[i][k]/U[k][k]; U[k][i] = _A[k][i]; } for (i = k + 1; i < n; i++) for (j = k + 1; j < n; j++) _A[i][j] -= L[i][k]*U[k][j]; } } int main( ) { float A[n][n] = { {2.0, 3.0, 1.0, 5.0}, {6.0, 13.0, 5.0, 19.0}, {2.0, 19.0, 10.0, 23.0}, {4.0, 10.0, 11.0, 31.0}}; float L[n][n], U[n][n]; int i, j; lu_decomposition(A, L, U); for (i = 0; i < n; i++) { printf("[ "); for (j = 0; j < n; j++) printf("%.2f ", L[i][j]); printf("] [ "); for (j = 0; j < n; j++) printf("%.2f ", U[i][j]); printf("]\n"); } return 0; } ================================================ FILE: other-languages/math/lu-decomposition/lu-decomposition.rb ================================================ =begin LU Decomposition Autor: ? Colaborador: José Alberto O. Morais Filho (j.moraisg12@gmail.com) Tipo: math Descrição: Fatora uma matriz não singular em duas matrizes triangulares, uma superior (upper) e uma inferior (lower). É utilizado para facilitar resoluções de sistemas de equações lineares ou o cálculo de determinates. Complexidade: O(n^3) Dificuldade: medio Referências: [1] http://en.wikipedia.org/wiki/LU_decomposition [2] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 819-822) =end # Entrada: # a = array a ser fatorado # Saída: # dois arrays, l e u def lu_decompose(a) n = a.length for i in 0..n-1 do for j in 0..n-1 do a[i][j] = a[i][j].to_f end end u = Array.new(n) {Array.new(n) {0}} l = Array.new(n) {Array.new(n) {0}} for i in 0..n-1 do for j in 0..n-1 do l[i][i] = 1 if i == j end end for k in 0..n-1 do u[k][k] = a[k][k] for i in k+1..n-1 do l[i][k] = a[i][k] / u[k][k] u[k][i] = a[k][i] end for i in k+1..n-1 do for j in k+1..n-1 do a[i][j] = a[i][j] - l[i][k]*u[k][j] end end end return l, u end # Exemplos a = [[1, 3, 2], [9, 5, 4], [8, 6, 7]] l, u = lu_decompose(a) print "L: #{l}, U: #{u}" puts b = [[4, 3, 8, 4], [12, 1, 9, 13], [5, 14, 2, 10], [6, 16, 7, 11]] l, u = lu_decompose(b) print "L: #{l}, U: #{u}" ================================================ FILE: other-languages/math/matrix-transpose/matrix-transpose.cpp ================================================ /* Transposição de matrizes Autor: ? Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: math Descrição: Calcula a matriz tranposta de uma matriz qualquer, ou seja, a matriz resultante da troca das linhas pelas colunas. Complexidade de tempo: O(m*n) Dificuldade: facil Referências: http://en.wikipedia.org/wiki/Transpose */ #include const int m = 3; const int n = 4; double transpose(int a[m][n], int b[n][m]) { for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) b[j][i] = a[i][j]; } int main( ) { int a[m][n] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; int b[n][m]; int i, j; transpose(a, b); for (i = 0; i < n; i++) { for (j = 0; j < m; j++) std::cout << b[i][j] << " "; std::cout << "\n"; } return 0; } ================================================ FILE: other-languages/math/media/media.lisp ================================================ #| Calculo de media ponderada Autor: ? Colaborador: Daniel Valio Tipo: math Descricao: Calcula a media ponderada entre tres numeros. Complexidade: O(1) Dificuldade: facil |# (defun media (a b c &optional (peso-a 1) (peso-b 1) (peso-c 1)) (/ (+ (* a peso-a) (* b peso-b) (* c peso-c)) (+ peso-a peso-b peso-c))) ================================================ FILE: other-languages/math/media/media.php ================================================ ================================================ FILE: other-languages/math/media/media.rb ================================================ # encoding: utf-8 =begin Cálculo da média ponderada Autor: ? Colaborador: Bruno Lara Tavares Karlisson Bezerra Tipo: math Descrição: Calcula a média ponderada - é um algoritmo comum em qualquer curso de introdução à programação, que pode variar de acordo com os pesos. Complexidade: O(1) Dificuldade: facil =end def media(n1, n2, n3) p1, p2, p3 = 4, 5, 6 (n1 * p1 + n2 * p2 + n3 * p3).to_f / (p1 + p2 + p3) end puts media(7.0, 8.0, 10.0) ================================================ FILE: other-languages/math/media-num/media-num.c ================================================ /* Media Autor: ? Colaborador: Guilherme Carlos (@guiessence) Tipo: math Descrição: Calcula a média de numeros inseridos pelo usuário Complexidade: 0(1) Dificuldade: facil <<<<<<< HEAD ======= >>>>>>> 9bb9c79831232255550163f21f9098b8060bfae3 */ #include #include void main(){ float media, num; int qtd, i, cont = 0; printf("Digite a quantidade de numeros:\n"); scanf("%d", &qtd); for(i = 0; i < qtd; i++){ printf("Digite um numero:\n"); scanf("%f", &num); media = media + num; cont++; } media = media/cont; printf("Media: %.2f: \n",media); } ================================================ FILE: other-languages/math/media-num/media-num.rb ================================================ # -*- encoding: utf-8 -*- =begin Media Numerica Autor: ? Colaborador: Bruno Lara Tavares Guilherme Carlos (@guiessence) Tipo: math Descrição: Calcula a média de numeros inseridos pelo usuário Complexidade: 0(1) Dificuldade: facil =end def media(*args) sum = 0 args.each do |i| sum += i end sum.to_f / args.size end #Adicione a quantidade de numeros que for preciso puts media(2,3,4,10) ================================================ FILE: other-languages/math/multiply-matrix/multiply-matrix.cpp ================================================ /* Multiplicação de matrizes (método trivial) Autor: ? Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: math Descrição: É o algoritmo trivial para multiplicação de duas matrizes A e B, onde A é uma matriz m x n e B é uma matriz n x p, a partir da definição matemática. Complexidade de tempo: O(m*n*p) Dificuldade: facil */ #include const int m = 3; const int n = 5; const int p = 4; /* Parâmetros: a: matriz (m x n) b: matriz (n x p) c: matriz para armazenar o resultado (m x p) */ void matrix_multiplication(int a[m][n], int b[n][p], int c[m][p]) { int i, j, k; for (i = 0; i < m; i++) for (j = 0; j < p; j++) c[i][j] = 0; for (i = 0; i < m; i++) for (j = 0; j < p; j++) for (k = 0; k < n; k++) c[i][j] += a[i][k] * b[k][j]; } int main( ) { int a[m][n] = { {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}}; int b[n][p] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}, {17, 18, 19, 20}}; int c[m][p]; matrix_multiplication(a, b, c); for (int i = 0; i < m; i++) { for (int j = 0; j < p; j++) std::cout << c[i][j] << " "; std::cout << "\n"; } return 0; } ================================================ FILE: other-languages/math/n-root/MetodosNumericos.java ================================================ /* Método numérico para resolução de raiz enésima Autor: ? Colaborador: Guilherme de Sales Orioli gui.orioli@gmail.com Tipo: math Descrição: Tira a raíz n-ésima de x, permitindo um erro máximo de error-allowed Exemplo: root(-123,5,0.0001); Saída: -2.618068900925607 Complexidade: ? Dificuldade: ? */ public class MetodosNumericos{ public static void main(String args[]){ System.out.println(root(16, 2, 0.000001)); } public static double root (double x, int n, double error_allowed){ double r,test=0; int i; boolean negative = false; boolean fraction = false; if (x < 0){ if(n%2==0) return 0; negative = true; x = -x; } if ( (x>0) && (x<1)){ x = 1/x; fraction = true; } r=x; test=x+1; while ( (test < x-error_allowed) || (test > x+error_allowed) ){ if (test #include float recursive_pow (float x, int n) { if (n == 1) return x; if (n == 0) return 1; if (n < 0 && x != 0) return 1 / recursive_pow(x, -n); if (x == 0) return 0; float pow = recursive_pow (x, n/2); pow = pow * pow * recursive_pow(x, n % 2); return pow; } int main(void) { float x[] = {-3, -2, -1, 0, 1, 2, 3}; int n[] = {-3, -2, -1, 0, 1, 2, 3}; int i; int j; for (i = 0; i < 7; i++) for (j = 0; j < 7; j++) printf("%f^%d=%f\n",x[i], n[j], recursive_pow(x[i],n[j])); return 0; } ================================================ FILE: other-languages/math/stirlings-approximation/stirling.clj ================================================ (defn stirling [n] " Fórmula de Stirling Autor: Pedro Menezes DiogoK Tipo: math Descrição: A Fórmula de Stirling estabelece uma aproximação assintótica para o fatorial de um número. Referências: http://pt.wikipedia.org/wiki/F%C3%B3rmula_de_Stirling " (* (Math/sqrt (* 2 Math/PI n)) (Math/pow (/ n Math/E) n))) (dorun (for [n (range 1 10)] (println "fat" n "~" (stirling n)) )) ================================================ FILE: other-languages/number-theory/euclid/euclid.lisp ================================================ #| Algoritmo de Euclides Autor: Euclides de Alexandria Colaborador: Daniel Valio Tipo: number-theory Descricao: Algoritmo de Euclides em sua forma moderna. Complexidade: O(n^2) onde n e' o numero de digitos da entrada. Dificuldade: facil |# (defun euclides (a b) (if (/= b 0) (euclides b (mod a b)) a)) ================================================ FILE: other-languages/number-theory/euclid/euclid.rb ================================================ # encoding: utf-8 =begin Algoritmo de Euclides Autor: Euclides de Alexandria Colaborador: Bruno Lara Tavares Liquen Tipo: number-theory Descrição: Algoritmo de Euclides em sua forma moderna. Computa o máximo divisor comum (MDC) entre dois números inteiros. Parte do princípio de que o MDC não muda se o menor número for subtraído do maior. [1] [2] Complexidade: O(n^2), onde n é o número de dígitos da entrada. [3] O número de passos é no máximo log(max(a, b) * sqrt(5)) / log(phi), onde phi = 1.618... é a proporção áurea. [3] Dificuldade: facil Referências: [1] http://en.wikipedia.org/wiki/Euclidean_algorithm [2] http://pt.wikipedia.org/wiki/Algoritmo_de_Euclides [3] http://mathworld.wolfram.com/EuclideanAlgorithm.html =end def euclides(a, b) while b != 0 a, b = b, a % b end a end puts euclides(1071, 462) ================================================ FILE: other-languages/number-theory/inverse/inverse.c ================================================ /* Inverse Autor: JoseFernandoTolentino (JoseFernandoTolentino@gmail.com) Tipo: number-theory Descrição: Inverte os algarismos de um número Complexidade: Pior caso: O(infinito) Melhor caso: O(n) Dificuldade: facil Referências: */ #include int inverse(int input) { int x=input; int output=0; while (x>0) { output = output * 10 + x % 10; x = x / 10; } return output; } int main() { int input = 12345; int output= inverse(input); printf("Numero=%d\ninverso=%d\n", input, output); return 0; } ================================================ FILE: other-languages/number-theory/modular-exponentiation/modular-exponentiation.cpp ================================================ /* Exponenciação modular (utilizando representação binária) Autor: ? Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: number-theory Descrição: É um algoritmo que realiza eficientemente a exponenciação modular, ou seja, calculos do tipo a^b mod n. Esse tipo de cálculo é de extrema importância para a teoria dos números e para a criptografia, é uma das operações mais importantes no método de criptografia RSA. Complexidade: O(log b) Dificuldade: medio Referências: http://en.wikipedia.org/wiki/Modular_exponentiation Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. ISBN 978-0-262-53305-8. Página 957. */ #include int modular_exponentiation(int a, int b, int n) { int result, aux = 1; // aux: auxiliar para fazer a conversão binária de b // inicia com a potência de base 2 mais próxima de b while ( aux < b ) aux <<= 1; result = 1; // enquanto aux > 0 while ( aux ) { result = (result*result) % n; // se o dígito de b for 1 if ( b & aux ) result = (a*result) % n; // divide por 2 aux >>= 1; } return result; } int main( ) { std::cout << modular_exponentiation(5, 10, 30) << "\n"; std::cout << modular_exponentiation(3, 11, 5) << "\n"; std::cout << modular_exponentiation(11, 7, 17) << "\n"; return 0; } ================================================ FILE: other-languages/number-theory/odd/odd.c ================================================ /* Encontrando números Ímpares Autor: ??? Colaborador: Filipe Saraiva (filip.saraiva@gmail.com) Tipo: math Descrição: Dá-se um número inteiro não negativo; o algoritmo listará todos os números ímpares entre 0 e este número dado. Complexidade: O(n) Dificuldade: fácil */ #include // Função para imprimir os números ímpares // entre '0' e um número máximo dado. void numerosImpares(int num){ int contador = 0; /* * Maneira convencional: caso o número a ser comparado * tiver o resto da divisão diferente de '0', quer dizer que * o número não é um múltiplo de 2 - definição de número ímpar. */ for(contador = 0; contador <= num; contador++){ if((contador % 2) != 0){ printf("%d ", contador); } } /* * Maneira esperta - sabemos que o primeiro número ímpar é igual à 1. * Daí, basta apenas incrementar o contador em mais duas unidades. * Todos os demais números serão ímpares. * * Descomente a rotina abaixo para a "Maneira esperta". */ // for(contador = 1; contador <= num; contador = contador + 2){ // printf("%d ", contador); // } printf("\n"); } // Função main int main(){ // Número máximo a ser utilizado. // Troque-o por outro número qualquer. int limite = 13; // Chamada da função numerosImpares numerosImpares(limite); return 0; } ================================================ FILE: other-languages/number-theory/odd-even/odd-even.c ================================================ /* Par ou impar Autor: ? Colaboradores: Geraldo Neto email (glnetinho@hotmail.com) Prdro Arthur Duarte (pedroarthur.jedi@gmail.com) Tipo: number-theory Descricao: Verifica se os números são impares ou pares. Complexidade: O(n), Através de operação módulo O(1), Através de operador binário Dificuldade: facil */ #include /* Macro: retorna 1 se o número for impar ou 0 caso contrário */ #define oddOrEven(a) ((a) & 1) void main(void) { int v[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int i, par = 0, impar = 0; for (i=0; i<=8; i++){ if(v[i]%2==0){ par=par+1; } else { impar=impar+1; } } printf("%d numeros pares e %d impares\n", par, impar); } ================================================ FILE: other-languages/number-theory/sieve/sieve.cpp ================================================ /* Crivo de Eratóstenes Autor: Eratóstenes de Cirene Colaborador: ? Tipo: number-theory Descrição: O Crivo de Eratóstenes implementado em C++. É um algoritmo que serve para encontrar todos os números primos até um limite especificado. Complexidade: O(n log log n) Dificuldade: medio Referências: [1] http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes [2] http://mathworld.wolfram.com/SieveofEratosthenes.html */ #include #include /* A função pede dois parâmetros: - primo: um array de booleanos - n: o tamanho do array primo Após a execução do algoritmo, o vetor primo será tal que o valor da i-ésima posição será true se (i + 1) for primo, ou false caso contrário. (O 1 somado se deve ao fato de C++ ser uma linguagem com arrays que começam em 0. */ void eratostenes(bool primo[], int n) { int i, j, parada; primo[0] = false; for (i = 1; i < n; i++) { primo[i] = true; } parada = (int) sqrtf(n); for (i = 1; i < parada; i++) { if ( primo[i] == false ) continue; for (j = 2*i + 1; j < n; j += (i + 1)) primo[j] = false; } } int main( ) { const int n = 25; bool primo[n]; eratostenes(primo, n); for (int i = 0; i < 25; i++) std::cout << i + 1 << " " << primo[i] << "\n"; return 0; } ================================================ FILE: other-languages/number-theory/sieve/sieve.lisp ================================================ #| Crivo de Eratostenes Autor: Eratostenes de Cirene Colaborador: Daniel Valio Tipo: number-theory Descricao: Encontra todos os primos entre dois nu'meros. Complexidade: ? Dificuldade: Facil/medio |# (defun primop (numero) (when (> numero 1) (loop for i from 2 to (isqrt numero) never (zerop (mod numero i))))) (defun proximo-primo (numero) (loop for i from numero when (primop i) return i)) ;;; Agora vem a parte magica. (defmacro with-gensyms ((&rest names) &body body) `(let ,(loop for n in names collect `(,n (gensym))) ,@body)) ;;; A macro do-primes aceita uma lista com nome de uma variavel, o limite inferior ;;; e o limite superior. Exemplo: ;;; ;;; (do-primes (alguma-var-inutil 0 100) ;;; (print alguma-var-inutil)) ;;; ;;; Esse exemplo retorna todos os primos de 0 a 100. (defmacro do-primes ((var start end) &body body) (with-gensyms (ending-value-name) `(do ((,var (proximo-primo ,start) (proximo-primo (1+ ,var))) (,ending-value-name ,end)) ((> ,var ,ending-value-name)) ,@body))) ================================================ FILE: other-languages/pattern-matching/lcs/lcs.rb ================================================ # LCS (Longest Common Subsequence) # Autor: # ? # Colaborador: # Luiz Fernando Oliveira Corte Real # Tipo: # pattern-matching # Descrição: # Este algoritmo calcula a maior string que subsequência de outras duas, # chamada de subsequência comum máxima ou, em inglês, longest common # subsequence (LCS). # # Por exemplo, dada a string 'banana' e a string 'abacate', a maior string # que é substring das duas é 'baa', que pode ser encontrada se pegarmos a # primeira (b), a segunda (a) e quarta letra (a) da palavra 'banana', ou a # segunda (b), a terceira (a) e a quinta letra (a) da palavra 'abacate'. # # O algoritmo baseia-se em programação dinâmica para calcular, primeiro, # o tamanho da maior substring das duas strings dadas. Ele faz isso # colocando, na matriz lcs_matrix, o tamanho da maior substring das duas até # certo ponto. Ou seja, na posição [i, j] da matriz teremos o tamanho da # LCS das strings string1[1..i] e string2[1..j] (os primeiros i caracteres # da string1 e os primeiros j caracteres da string2). O algoritmo vai # preenchendo essa matriz pelas linhas, com base nas strings e numa # fórmula de recorrência. No fim, o tamanho da LCS das duas strings estará # na última posição preenchida da matriz. # # Para recuperar qual é essa LCS, o algoritmo percorre a matriz procurando # quais foram as posições das strings que fizeram o tamanho ser # incrementado. # Complexidade: # O(nm), onde n e m são os tamanhos das strings dadas # Referências: # http://en.wikipedia.org/wiki/Longest_common_subsequence_problem # Licença: # BSD class LCS def initialize(string1, string2) @string1 = string1 @string2 = string2 end def length @lcs_matrix ||= compute_lcs_matrix return @lcs_matrix[@string1.size][@string2.size] end def string return '' if @string1.empty? or @string2.empty? @lcs_matrix ||= compute_lcs_matrix @lcs_string ||= find_lcs_in_matrix return @lcs_string end private def compute_lcs_matrix counting = [] (@string1.size+1).times { counting << Array.new(@string2.size+1, 0) } @string1.size.times do |i| @string2.size.times do |j| if @string1[i] == @string2[j] counting[i+1][j+1] = counting[i][j] + 1 else counting[i+1][j+1] = [counting[i+1][j], counting[i][j+1]].max end end end return counting end def find_lcs_in_matrix return recursive_find_lcs_in_matrix(@string1.size, @string2.size) end def recursive_find_lcs_in_matrix(i, j) return '' if i == 0 or j == 0 if @string1[i-1] == @string2[j-1] return recursive_find_lcs_in_matrix(i-1, j-1) + @string1[i-1].chr end if @lcs_matrix[i][j-1] > @lcs_matrix[i-1][j] return recursive_find_lcs_in_matrix(i, j-1) end return recursive_find_lcs_in_matrix(i-1, j) end end ################################################### # Exemplos de uso, com resultados esperados ao lado ################################################### puts LCS.new('a string', 'another string').string # 'a string' puts LCS.new('yes', 'not').length # 0 puts LCS.new('french', 'trench').string # 'rench' ================================================ FILE: other-languages/physics/ballistic/ballistic.lisp ================================================ #| Balistica Autor: ? Colaborador: Daniel Valio Tipo: physics Complexidade: O(1) Dificuldade: Facil |# (defun backend-tiro (vetor-horizontal vetor-vertical gravidade &optional (x 0) (y 0) (time 0) (angulo 0)) (if (> y 0) (backend-tiro vetor-horizontal vetor-vertical gravidade (* time vetor-horizontal) (- (+ y (* time vetor-vertical)) (* gravidade (expt time 2))) (1+ time)) (list angulo x y))) (defun simula-tiro (angulo forca gravidade y) (backend-tiro (* forca (cos angulo)) (* forca (sin angulo)) gravidade 0 y 0 angulo)) ================================================ FILE: other-languages/puzzle/hanoi/hanoi.cpp ================================================ /* Torre de Hanói Autor: ? Colaborador: Ramon Caldeira (ramoncaldeira_328@hotmail.com) Tipo: misc Descrição: O algoritmo resolve recursivamente o puzzle Torre de Hanói para n discos. A idéia é basicamente resolver a torre para menos discos usando o pino auxiliar como destino e resolvê-la novamente. O caso base: resolver a torre com um disco Complexidade: ? Dificuldade: medio */ #include const char* pino[3] = { "pino inicial", "pino auxiliar", "pino destino" }; /* @param nDiscos => número de discos que a torre inicialmente contém @param pInicial => pino onde se colocam os discos inicialmente @param pAuxiliar => pino usado momentâneamente para trocar os discos de pino @param pDestino => pino aonde os discos terminam */ void hanoi(int nDiscos, int pInicial = 0, int pAuxiliar = 1, int pDestino = 2) { if(!nDiscos) return; hanoi(nDiscos - 1, pInicial, pDestino, pAuxiliar); std::cout << "move disco do " << pino[pInicial] << " ao " << pino[pDestino] << std::endl; hanoi(nDiscos - 1, pAuxiliar, pInicial, pDestino); } /* rotina de teste */ int main() { int discos = 3; hanoi(discos); std::cin.get(); } ================================================ FILE: other-languages/puzzle/sudoku-validation/sudoku-validation.cpp ================================================ /* Valida solução de sudoku Autor: ? Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: puzzle Descrição: Algoritmo que verifica se um jogo de sudoku está corretamente preenchido ou não, de acordo com as regras do jogo. Utiliza a ideia de que, se um conjunto tem somente de 1 a 9 sem duplicidade, então a soma de todos os elementos é constante. Complexidade: O(1) Dificuldade: facil Referências: http://en.wikipedia.org/wiki/Sudoku */ #include bool validate_sudoku(int sudoku[9][9]) { // 1 + 2 + 3 + 4 + ... + 9 const int SUM_9 = 45; // inicializa somas com 0 int sum_line[9], sum_column[9], sum_matrix[3][3]; int i, j; for (i = 0; i < 9; i++) sum_line[i] = sum_column[i] = sum_matrix[i/3][i%3] = 0; for (i = 0; i < 9; i++) for (j = 0; j < 9; j++) { sum_line[i] += sudoku[i][j]; sum_column[j] += sudoku[i][j]; sum_matrix[i/3][j/3] += sudoku[i][j]; } for (i = 0; i < 9; i++) if ( sum_column[i] != SUM_9 || sum_line[i] != SUM_9 || sum_matrix[i/3][i%3] != SUM_9 ) return false; return true; } int main( ) { int game[9][9] = { {5, 3, 4, 6, 7, 8, 9, 1, 2}, {6, 7, 2, 1, 9, 5, 3, 4, 8}, {1, 9, 8, 3, 4, 2, 5, 6, 7}, {8, 5, 9, 7, 6, 1, 4, 2, 3}, {4, 2, 6, 8, 5, 3, 7, 9, 1}, {7, 1, 3, 9, 2, 4, 8, 5, 6}, {9, 6, 1, 5, 3, 7, 2, 8, 4}, {2, 8, 7, 4, 1, 9, 6, 3, 5}, {3, 4, 5, 2, 8, 6, 1, 7, 9}}; std::cout << validate_sudoku(game); return 0; } ================================================ FILE: other-languages/search/binary-search/BuscaBinaria.java ================================================ /* * BuscaBinaria * Autor: * Jon Bentley * Colaborador: * Fabiano Sobreira * Tipo: * search * Descrição: * A pesquisa ou busca binária (em inglês binary search algorithm ou binary * chop) é um algoritmo de busca em vetores que requer acesso aleatório aos * elementos do mesmo. Ela parte do pressuposto de que o vetor está ordenado * e realiza sucessivas divisões do espaço de busca (divisão e conquista) * comparando o elemento buscado (chave) com o elemento no meio do vetor. * Complexidade: * ? * Dificuldade: * fácil * Referências: * http://pt.wikipedia.org/wiki/Pesquisa_binária */ public class BuscaBinaria { private int[] vetor; private int valorProcurado; private int menor; private int maior; public BuscaBinaria(int[] vetor, int valorProcurado) { this.vetor = vetor; this.valorProcurado = valorProcurado; menor = 0; maior = vetor.length - 1; } public int getPosicao() { while (menor < maior) { int meio = menor + ((maior - menor) / 2); int valorMeio = vetor[meio]; if (valorProcurado < valorMeio) maior = meio; else if (valorProcurado > valorMeio) menor = meio + 1; else return meio; } return -1; } /* * Método de exemplo para verificação do algorítimo. O algoritimo pode ser * executado da seguinte maneira: java BuscaBinaria 1000 799 */ public static void main(String[] args) { if (args.length < 2) throw new IllegalArgumentException("informe o tamanho do vetor e o valor procurado"); int tamanho = Integer.parseInt(args[0]); int alvo = Integer.parseInt(args[1]); int[] vetor = new int[tamanho]; for (int i = 0; i < vetor.length; i++) vetor[i] = i; BuscaBinaria bs = new BuscaBinaria(vetor, alvo); int resultado = bs.getPosicao(); if (resultado == -1) System.out.println("Não encontrado."); else System.out.println("Encontrado na posição: " + resultado + "."); } } ================================================ FILE: other-languages/search/linear-search/linear-search.rb ================================================ =begin Linear Search Autor: ? Colaborador: José Alberto O. Morais Filho (j.moraisg12@gmail.com) Tipo: search Descrição: Utiliza força bruta em um array para retornar a posição de um valor nesse array, ou retornar -1, se nada for encontrado. Complexidade: O(n) Dificuldade: fácil =end # Entrada: # array = vetor onde o valor será pesquisado # search = valor procurado # Saída: # a posição da primeira ocorrência do valor, ou -1, caso o valor não for encontrado def linear_search(array, search) array.each_index {|i| return i if array[i] == search} -1 end # Exemplos a = [1,5, 6, 3, 7,4] print linear_search(a, 6) print linear_search(a, 60) ================================================ FILE: other-languages/search/simul-smaller-higher/simul-smaller-higher.cpp ================================================ /* Menor e maior elemento simultâneo Autor: ? Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: search Descrição: É um algoritmo que pesquisa o menor e o maior elemento do vetor simultaneamente, economizando, assim, comparações. Enquanto utizando pesquisa de menor e maior elementon separadamente são necessárias 2n-2 comparações, com esse algoritmo, o número de comparações é reduzido para aproximadamente 1,5n. [1] O algoritmo funciona da seguinte forma: divide-se o vetor em pares, compara-se os dois elementos dos pares, compara-se o menor com o valor minimo armazenado e o maior com o valor máximo armazenado, assim, tem um custo de 3 comparações para cada 2 elementos, resultando em aproximadamente 1,5n comparações. Complexidade: O(n) Dificuldade: facil Referências: [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition, páginas 214-215 */ #include /* Parâmetros: a: o vetor n: o número de elementos min: variável para armazenar a posição do menor valor max: variável para armazenar a posição do maior valor */ void min_max(int a[], int n, int &min, int &max) { int i = 0; min = max = 0; // valida o caso do número de elementos ser ímpar if ( n % 2 != 0 ) { i = 1; } for (; i < n; i += 2) { if ( a[i] < a[i + 1] ) { if ( a[i] < a[min] ) min = i; if ( a[i + 1] > a[max] ) max = i + 1; } else { if ( a[i + 1] < a[min] ) min = i + 1; if ( a[i] > a[max] ) max = i; } } } int main( ) { int a[] = {8, 2, 5, 3, 1, 7, 6, 4}; int min, max; min_max(a, 8, min, max); std::cout << "Menor valor: " << a[min] << "\n"; std::cout << "Maior valor: " << a[max] << "\n"; return 0; } ================================================ FILE: other-languages/sequence/token/token.php ================================================ Colaborador: Sérgio Mandrake Tipo: sequence Descrição: Gera um token aleatório Complexidade: ? Dificuldade: facil */ function token($comprimento = 6) { $caracteres = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'; $totalCarac = strlen($caracteres) -1; $resultado = ''; for ($i = 0; $i < $comprimento; $i++) { $resultado .= $caracteres[mt_rand(0, $totalCarac)]; } return $resultado; } echo token(5); ================================================ FILE: other-languages/sequence/token/token.rb ================================================ # -*- coding: UTF-8 -*- =begin Token Autor: ? Colaborador: Bruno Lara Tavares Felipe Djinn Tipo: sequence Descrição: Gera um token aleatório Complexidade: ? Dificuldade: facil =end def token(length = 10) rand(36**length).to_s 36 end """ Examples """ puts "Token com 10 caracteres (padrão): " + token() puts "Token com 5 caracteres: " +token(5) puts "Token com 15 caracteres " +token(15) ================================================ FILE: other-languages/sorting/bozosort/bozosort.lisp ================================================ #| Bozosort (a.k.a Bogosort) Autor: Bozo Tipo: sorting Descricao: Embaralha um vetor indefinidamente, ate' que os numeros estejam em ordem. Complexidade: O(infinito) PS: Essa versao trabalha com listas, e nao vetores de fato. |# (defun shuffle-list (l) (loop for i below (length l) do (rotatef (elt l i) (elt l (random (length l))))) l) (defun bozosort (lista) (if (equalp lista (sort lista #'<)) lista (bozosort (shuffle-list lista)))) ================================================ FILE: other-languages/sorting/bozosort/bozosort.php ================================================ "; print_r(($ordenado==true)? $valores: ""); } } // Passando um array com valores a serem ordenados bogo(array(3,5,2,1)); ?> ================================================ FILE: other-languages/sorting/bozosort/bozosort.rb ================================================ =begin Bozosort Autor: Bozo Colaborador: Caio Tipo: sorting Descrição: Embaralha um vetor indefinidamente, até que os números estejam em ordem. Complexidade: O(infinito) Dificuldade: facil Referências: http://nerdson.com/blog/libbozo-01/ http://pt.wikipedia.org/wiki/Bogosort =end require 'test/unit' class Array def bozosort list = self.sort while self != list self.shuffle! end self end end class TestBozosort < Test::Unit::TestCase def test_bozosort randon_array = Array.new(rand(20)).map{rand(99999999)} sorted_array = randon_array.sort assert_equal randon_array.bozosort, sorted_array end end ================================================ FILE: other-languages/sorting/bubblesort/bubblesort.lisp ================================================ #| Bubble sort Autor: Desconhecido Tipo: Ordenacao de vetores Descricao: Compara elementos dois a dois e checa se estao na ordem correta. Complexidade: Pior caso: O(n²) Melhor caso: O(n²) |# (defun bubble-sort (array) (let ((result (copy-seq array))) (loop for i from (1- (length result)) downto 0 do (loop for j from 0 to i when (< (aref result i) (aref result j)) do (rotatef (aref result i) (aref result j)))) result)) ================================================ FILE: other-languages/sorting/bubblesort/bubblesort.php ================================================ ================================================ FILE: other-languages/sorting/fisher-yates/fisher-yates.c ================================================ /* Fisher–Yates shuffle, Knuth shuffle (Durstenfeld's Solution) Autor: Ronald Fisher, Frank Yattes, Donald Knuth, Richard Durstenfeld Colaborador: Anderson "Cacovsky" Marques Ferraz amarquesferraz@gmail.com Tipo: sorting Descrição: Embaralha um vetor de numeros sequenciais. Nao utiliza nenhum vetor auxiliar (in-place) e so realiza tantos sorteios quanto posicoes do vetor. Complexidade: O(n) Dificuldade: medio Referências: http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle Licenca: LGPL */ #include #include #include /** * gera uma lista ordenada */ int * gera_vetor_ordenado(int qtde_elementos) { int i; int *resultado= (int*) malloc(qtde_elementos*sizeof(int)); for (i=0; i0){ int k = rand() % (elementos_restantes); //passo 2 //passo 3 int tmp = elementos[k]; elementos[k] = elementos[elementos_restantes-1]; elementos[elementos_restantes-1] = tmp; elementos_restantes--; //passo 4 } printf("Vetor embaralhado: "); imprime_vetor(elementos, N); return 0; } ================================================ FILE: other-languages/sorting/heapsort/heapsort.c ================================================ /* Heap Sort Autor: Robert W. Floyd e J.W.J. Williams. Colaborador: Ramon Caldeira Faria (ramoncaldeira_328@hotmail.com) Tipo: sorting Descrição: O algoritmo serve para ordenar uma estrutura de dados, no caso desta implementação um vetor. Complexidade: O(n lgn) Dificuldade: medio */ void buildMaxHeap(int*, int); void maxHeapify(int*, int, int); void swap (int*, int, int); /*** - transforma o array numa heap de máximo heap: árvore binária com propriedade de heap propriedade de heap: um nó deve ser maior que seus filhos. o array como arvore binaria: | raiz | n1 | n1 | n2 | n2 | n2 | n2 | ... - para todos os filhos: - retira o nó raiz (maior número) e separa - reconstrói a heap ***/ void heapSort(int* array, int size) { buildMaxHeap(array, size); int n = size; for (int i=(size-1); i>0; i--) { swap(array, i , 0); maxHeapify(array, 0, --n); } } /* percorre todos os nós que não são folha e reconstroe-se uma sub-heap tendo ele como raiz de baixo pra cima */ void buildMaxHeap(int* array, int size) { for (int i = size/2 - 1; i >= 0; i--) maxHeapify(array, i , size); } /* aplica a propriedade de heap */ void maxHeapify(int* array, int pos, int n) { int max = 2 * pos + 1, right = max + 1; if (max < n) { if ( right < n && array[max] < array[right]) max = right; if (array[max] > array[pos]) { swap(array, max, pos); maxHeapify(array, max, n); } } } void swap ( int* v, int i, int j ) { int aux = v [i]; v [i] = v [j]; v [j] = aux; } ================================================ FILE: other-languages/sorting/insertionsort/insertionsort.cpp ================================================ /* InsertionSort Autor: ? Colaborador: Willian Tipo: sorting Descrição: Varre o vetor organizando-o em ordem crescente. Só pula para o próximo elemento depois de organizar todos os elementos anteriores. Complexidade: O(n²) Dificuldade: facil Referências: http://pt.wikipedia.org/wiki/Insertion_sort */ #include using namespace std; /* * Parâmetros * int vetor[] * Vetor de números inteiros * int tam * Quantidade de elementos do vetor 'vetor[]' */ void insertionSort(int vetor[], int tam) { //Vamos começar o loop pelo segundo elemento do vetor for(int i=1;i vetor[proximo]) { tmp = vetor[anterior]; vetor[anterior] = vetor[proximo]; vetor[proximo] = tmp; } else troca = false; anterior--; proximo = anterior + 1; //Verificando o limite do vetor if (anterior<0) troca = false; } while(troca); } } //exemplo de uso int main(void) { //Criando um vetor de testes int vetor[] = { 98, 78, 2, 4, 100, -2 }; int tam = sizeof(vetor) / sizeof(int); //Chamando a função de ordenação com o vetor e o tamanho insertionSort(vetor, tam); //Imprimindo for(int i=0; i $vetor[$proximo]) { $tmp = $vetor[$anterior]; $vetor[$anterior] = $vetor[$proximo]; $vetor[$proximo] = $tmp; } else $troca = false; $anterior--; $proximo = $anterior + 1; if ($anterior<0) $troca = false; } } return $vetor; } $vetor = array(98, 78, 2, 4, 100, -2 ); $vetor = insertionSort($vetor); for($i=0; $i'; ?> ================================================ FILE: other-languages/sorting/insertionsort/insertionsort.rb ================================================ # encoding: utf-8 =begin Insertion Sort Autor: ? Tipo: sorting Colaborador: Bruno Lara Tavares Descrição: Percorre uma lista da esquerda para direita e vai deixando os elementos mais a esquerda ordenados à medida que avança pela lista. Complexidade: Pior caso: O(n²) Melhor caso: O(n) Dificuldade: Facil Referencia: http://pt.wikipedia.org/wiki/Insertion_sort =end class Array def insertion_sort!() (1..self.size-1).each do |i| elemento = self[i] j = i - 1 while j >= 0 && self[j] > elemento self[j+1] = self[j] j -= 1 self[j+1] = elemento end end self end end puts [5,6,8,1].insertion_sort!.inspect ================================================ FILE: other-languages/sorting/mergesort/mergesort.c ================================================ /* Mergesort Autor: John von Neumann, em 1945 Colaborador: Luiz Fernando Oliveira Corte Real (luiz@vidageek.net) Tipo: sorting Descrição: O algoritmo ordena um vetor dividindo-o pela metade e, depois de processar cada metade recursivamente, intercala as metades ordenadas. Complexidade: O(n lgn) Dificuldade: fácil Referências: [1] http://en.wikipedia.org/wiki/Merge_sort */ #include #define TAMANHO_MAXIMO 100000 /* Intercala duas metades ordenadas do vetor v: de inicio até meio-1 e de meio até fim-1 */ void intercala(int v[], int inicio, int meio, int fim) { int vetor_auxiliar[TAMANHO_MAXIMO]; int indice_parte_1, indice_parte_2, indice_vetor_auxiliar; indice_parte_1 = inicio; indice_parte_2 = meio; indice_vetor_auxiliar = 0; /* Mescla as metades até uma delas acabar */ while (indice_parte_1 < meio && indice_parte_2 < fim) { if (v[indice_parte_1] < v[indice_parte_2]) { vetor_auxiliar[indice_vetor_auxiliar] = v[indice_parte_1]; indice_parte_1++; } else { vetor_auxiliar[indice_vetor_auxiliar] = v[indice_parte_2]; indice_parte_2++; } indice_vetor_auxiliar++; } /* Uma das metades pode ter ficado com elementos sobrando; apenas copiamos esses elementos */ while (indice_parte_1 < meio) { vetor_auxiliar[indice_vetor_auxiliar] = v[indice_parte_1]; indice_parte_1++; indice_vetor_auxiliar++; } while (indice_parte_2 < meio) { vetor_auxiliar[indice_vetor_auxiliar] = v[indice_parte_2]; indice_parte_2++; indice_vetor_auxiliar++; } /* Copia o vetor auxiliar no lugar certo em v (de trás pra frente para não * ter que calcular o tamanho do pedaço que vamos copiar; esse tamanho já * está na variável indice_vetor_auxiliar) */ while (indice_vetor_auxiliar > 0) { indice_vetor_auxiliar--; v[inicio + indice_vetor_auxiliar] = vetor_auxiliar[indice_vetor_auxiliar]; } } /* Ordena o vetor v de inicio até fim-1 */ void mergesort_recursivo(int v[], int inicio, int fim) { int meio = (inicio + fim) / 2; /* Só chama a recursão na primeira metade se houver mais de um elemento lá */ if (inicio < meio - 1) { mergesort_recursivo(v, inicio, meio); } /* Idem para a segunda metade */ if (meio < fim - 1) { mergesort_recursivo(v, meio, fim); } intercala(v, inicio, meio, fim); } void mergesort(int v[], int n) { mergesort_recursivo(v, 0, n); } int main() { int vetor[] = { 5, 14, 8, 17, 1, -3, 9}; int n = 7; /* número de elementos no vetor */ int i; mergesort(vetor, n); printf("vetor ordenado:"); for (i = 0; i < n; i++) { printf(" %d", vetor[i]); } printf("\n"); return 0; } ================================================ FILE: other-languages/sorting/mergesort/mergesort.rb ================================================ =begin Mergesort Autor: ? Colaborador: José Alberto O. Morais Filho (j.moraisg12@gmail.com) Tipo: sorting Descrição: Um dos melhores algoritmos de ordenação existente. Recebe um vetor, e, recursivamente, aplica a função Merge nos subvetores. A função merge recebe dois subvetores e os agrupa em um array ordenado. Complexidade: O(n log n) Dificuldade: médio Referências: [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 29-34) =end def merge(array, left, mid, right) n1 = mid - left + 1 n2 = right - mid l = Array.new(n1 + 1) {0} r = Array.new(n2 + 1) {0} for i in 0...n1 do l[i] = array[left + i] end for j in 1..n2 do r[j - 1] = array[mid + j] end l[n1] = 999999 r[n2] = 999999 i = 0 j = 0 for k in left..right do if l[i] <= r[j] then array[k] = l[i] i += 1 else array[k] = r[j] j += 1 end end end def mergesort(array, left, right) if left < right then mid = (left + right) / 2 mergesort(array, left, mid) mergesort(array, mid + 1, right) merge(array, left, mid, right) end end a = [5, 3, 4, 1, 9, 7, 2, 6, 8] mergesort(a, 0, 8) print a puts b = [8, 1, 3, 2, 5, 7, 6, 4] mergesort(b, 0, 7) ================================================ FILE: other-languages/sorting/quicksort/quicksort.c ================================================ /* Quicksort Autor: C.A.R. Hoare Colaborador: Dayvid Victor (victor.dvro@gmail.com) Tipo: sorting Descrição: Quicksort é um algorítmo de ordenação de vetores cuja estratégia é dividir para conquistar. Basicamente o algorítmo organiza os elementos dos vetores de forma que os menores estejam antes dos maiores. Esse passo é feito recursivamente até que a lista completa esteja ordenada. Complexidade: O(n log(n)) - Melhor caso e médio caso. O(n²) - Pior caso. Dificuldade: facil Referências: (opcional) http://pt.wikipedia.org/wiki/Quicksort#C */ #include #include void swap (int vector[], int a, int b) { int temp = vector[a]; vector[a] = vector[b]; vector[b] = temp; } void quicksort(int vector[], int begin, int end) { if (begin >= end) return; int i = begin; int j = end; int pivot = vector[(begin + end)/2]; while (vector[i] < pivot) i = i + 1; while (vector[j] > pivot) j = j - 1; if (i <= j) { swap(vector, i, j); i++; j--; } quicksort(vector, begin, j); quicksort(vector, i, end); } int main() { int vector[] = {2, 7, 3, 8, 4, 9, 1, 0, -1}; int size = 9; int i; for (i = 0; i < size; i++){ printf("%d ", vector[i]); } printf("\n"); quicksort(vector, 0, size); for (i = 0; i < size; i++){ printf("%d ", vector[i]); } printf("\n"); return 0; } ================================================ FILE: other-languages/sorting/quicksort/quicksort.php ================================================ = $chave; })) ); } $vet = array(2, 7, 3, 8, 4, 9, 1, 0, -1); $tam = count($vet); for ($i = 0; $i < $tam; $i++){ echo $vet[$i]; } echo "\n"; $vet_ordenado = quicksort($vet); for ($i = 0; $i < $tam; $i++){ echo $vet_ordenado[$i]; } echo "\n"; ?> ================================================ FILE: other-languages/sorting/quicksort/quicksort.rb ================================================ =begin Quicksort Autor: ? Colaborador: José Alberto O. Morais Filho (j.moraisg12@gmail.com) Tipo: sorting Descrição: Um dos melhores algoritmos de ordenação existente. Recebe um vetor, e, recursivamente, aplica a função Partition nos subvetores. A função partition reposiciona os valores de um array de tal forma que todos os elementos da esquerda do pivô (ultimo elemento) sejam menores que ele e os da direita sejam maiores. Complexidade: O(n log n) Dificuldade: médio Referências: [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 170-174) [2] http://en.wikipedia.org/wiki/Quicksort =end # Entrada: # array = um vetor a ser ordenado; # left = primeira posição do vetor (ou subvetor); # right = última posição do vetor (ou subvetor); # Saída: # o vetor ordenado def partition(array, left, right) x = array[right] i = left - 1 for j in left...right do if array[j] <= x then i += 1 array[i], array[j] = array[j], array[i] end end array[i + 1], array[right] = array[right], array[i + 1] i + 1 end def quicksort(array, left, right) if left < right then q = partition(array, left, right) quicksort(array, left, q - 1) quicksort(array, q + 1, right) end end # Exemplos a = [2, 8, 7, 1, 3, 5, 6, 4] b = [3, 1, 2, 6, 7, 4, 5] quicksort a, 0, 7 print a puts quicksort b, 0, 6 print b ================================================ FILE: other-languages/sorting/selectionsort/selectionsort.cpp ================================================ /* Selection Sort Autor: ? Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: sorting Descrição: É um algoritmo de ordenação que consiste em pesquisar o menor elemento e colocar na primeira posição, o segundo menor e colocar na segunda posição e assim sucessivamente, até que a sequência esteja ordenada. É uma excelente escolha quando há necessidade quando o custo de escrita é alto, pois ele realiza em torno de 2n operações de escrita. [2] Complexidade de tempo: O(n²) Dificuldade: facil Referências: [1] http://en.wikipedia.org/wiki/Selection_sort [2] http://en.wikipedia.org/wiki/Selection_sort#Comparison_to_other_sorting_algorithms */ #include void selection_sort(int a[], int n) { int i, j, min; int temp; for (i = 0; i < n-1; i++) { min = i; // encontra o menor elemento for (j = i + 1; j < n; j++) if ( a[j] < a[min] ) min = j; // insere o menor elemento encontrado na posição correta temp = a[i]; a[i] = a[min]; a[min] = temp; } } int main( ) { int a[] = {6, -2, 3, 5, 7, 4, 3}; selection_sort(a, 7); for (int i = 0; i < 7; i++) std::cout << a[i] << " "; return 0; } ================================================ FILE: other-languages/sorting/selectionsort/selectionsort.php ================================================ "; ?> ================================================ FILE: other-languages/sorting/shellsort/shellsort.cpp ================================================ /* Shell Sort Autor: Donald Shell Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: sorting Descrição: É um método que funciona repetidamente ordenando com insertion sort elementos com uma distância, inicialmente grande e que vai diminuindo de acordo com uma sequência, até que a distância é 1 e o vetor é finalmente ordenado. Complexidade de tempo: O(n^1.5) Dificuldade: medio Referências: http://en.wikipedia.org/wiki/Shell_sort http://www.iti.fh-flensburg.de/lang/algorithmen/sortieren/shell/shellen.htm */ #include void shell_sort(int a[], int n) { int dist = 1; int i, j, temp; // Essa implementação do Shell Sort utiliza incrementos da forma 2^k - 1: // 1, 3, 7, 15, 31, 63, 127, ... // Aqui é determinado qual é o incremento inicial: // o maior incremento da forma 2^k - 1 que não é menor que n while ( 2*dist < n ) dist = 2*dist + 1; while ( dist > 0 ) { // Faz insertion sort com distancia dist (h-sort) for (i = dist; i < n; i++) { temp = a[i]; for (j = i - dist; j >= 0 && temp < a[j]; j -= dist) a[j + dist] = a[j]; a[j + dist] = temp; } // diminui a distância dist = dist / 2; } } int main( ) { int a[] = {6, -2, 3, 5, 7, 4, 3, 10, -1, 8}; shell_sort(a, 10); for (int i = 0; i < 10; i++) std::cout << a[i] << " "; return 0; } ================================================ FILE: other-languages/sorting/stoogesort/stoogesort.cpp ================================================ /* Stooge Sort Autores: Morris Howard, Lawrence Fine, Jerome Howard Colaborador: Luiz Rodrigo (luizrodri.go@hotmail.com) Tipo: sorting Descrição: É um algoritmo de ordenação recursivo bem de fácil implementação: verifica se o primeiro elemento é maior que o último, ordena os 2 primeiros terços do vetor, ordena os 2 ultimos e ordena os dois primeiros novamente. Apesar de elegante, é um algoritmo bem lento (pior até que o bubble sort). Complexidade: O(n^2.701) Dificuldade: facil Referências: [1] http://en.wikipedia.org/wiki/Stooge_sort */ #include void stooge_sort(int a[], int left, int right) { if ( a[left] > a[right] ) { int temp = a[left]; a[left] = a[right]; a[right] = temp; } if ( right-left > 1 ) { int k = (right-left+1)/3; stooge_sort(a, left, right-k); stooge_sort(a, left+k, right); stooge_sort(a, left, right-k); } } int main( ) { int a[] = {6, -2, 3, 5, 7, 4, 10, 3}; stooge_sort(a, 0, 7); for (int i = 0; i < 8; i++) std::cout << a[i] << " "; return 0; }