[ { "path": "README.md", "content": "# 1001 algoritmos para implementar antes de morrer\n\nVamos 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!\n\nOs códigos devem estar de acordo com os requisitos abaixo:\n\n* Siga este modelo de arquivo: [https://github.com/karlisson/1001/blob/master/modelo.txt](https://github.com/karlisson/1001/blob/master/modelo.txt)\n* Ser em Python. Lembre-se, é para iniciantes.\n* 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.\n* Navegue no repositório e veja os algoritmos já adicionados antes de submeter.\n* O código não pode depender de bibliotecas extras que precisam ser instaladas.\n* 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).\n* 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.\n\n" }, { "path": "algorithms/ai/Astar.py", "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo A* \nAutores: \n Peter Hart, Nils Nilsson and Bertram Raphael \nColaborador:\n \tPéricles Lopes Machado [gogo40] (pericles.raskolnikoff.gmail.com)\nTipo: \n graphs\nDescrição: \n O Algoritmo A* é uma generalização do algoritmo de Dijkstra que\npermite acelerar a busca com uma heuristica que utiliza propriedades do grafo \npara estimar a distância para o destino. Este algoritmo é ideal quando aplicados\nem grades ou representações espaciais e em situações em que já conhecemos a\nposição do destino.\n\nComplexidade: \n O(|E| log |V|)\nDificuldade: \n medio\nReferências:\n [1] http://en.wikipedia.org/wiki/A*_search_algorithm\n [2] http://falapericles.blogspot.com.br/2009/05/o-algoritmo.html\n\"\"\"\n\n\"\"\"\nFunção para imprimir o caminho\n\"\"\"\ndef imprime_caminho(pi, u):\n\tux = u[0];\n\tuy = u[1];\n\n\tif pi[ux][uy] == None:\n\t\tprint u;\n\telse:\n\t\timprime_caminho(pi, pi[ux][uy]);\n\t\tprint u;\n\n\"\"\"\nFunção para 'renderizar' o jogador numa posição da grade\n\"\"\"\ndef renderizar_grade(G, ux, uy):\n\tl = list(G[ux]);\n\tl[uy] = 'x';\n\tG[ux] = \"\".join(l);\n\n\tfor i in range(0, len(G)):\n\t\tprint \" \", G[i];\n\n\tprint \"---------\";\n\n\tl = list(G[ux]);\n\tl[uy] = '.';\n\tG[ux] = \"\".join(l);\n\n\"\"\"\nFunção para 'renderizar' a trajetória percorrida\n\"\"\"\ndef renderizar_caminho(pi, G, u):\n\tux = u[0];\n\tuy = u[1];\n\n\tif pi[ux][uy] == None:\n\t\trenderizar_grade(G, ux, uy);\n\telse:\n\t\trenderizar_caminho(pi, G, pi[ux][uy]);\n\t\trenderizar_grade(G, ux, uy);\n\nfrom heapq import *;\nfrom math import *;\n\n\n\"\"\"\nEste algoritmo utiliza uma grade para realizar a busca.\nA origem é marcada com o símbolo 'x' e o destino é marcado\ncom o simbolo '+'.\n\n\"\"\"\nG = [\n\"###..####################..####################..####################..####################..#################.\",\n\".........*........#.#..........*........#.#...........*........#.#...........*........#.............*.......#..\",\n\"....#....#.##.#####.#......#....#.##.#####.#......#....#.##.#####.#......#....#.##.#####........#....#.##.###..\",\n\"#...#....#..#......*..#...#....#..#......*..#...#....#..#......*..#...#....#..#......*......#....#..#......*...\",\n\"#.####...#*##+.....*.##.####...#*##......*.##.####...#*##......*.##.####...#*##......*.##.####...#*##......*.#.\",\n\"#....#..##.........#.##....#..##.........#.##....#..##.........#.##....#..##.........#.##..................#.#.\",\n\"#....#...#.###.##..####....#...#.###.##..####....#...#.###.##..####....#...#.###.##..####........#.###.##..###.\",\n\"#....#.......#..#....##....#.......#..#....##....#.......#..#....##....#...............##............#..#....#.\",\n\"#....#.......#..#....##....#.......#..#....##....#.......#..#....##....#.............................#..#....#.\",\n\"###..#.##########.#######..#.##########.#######..#.##########.#######..#.##########.##.####..#.##########.####.\",\n\"#...##.....#....#.#.......##.....#....#.#..##...##.....#....#.#.......##.....#....#.#.......##.....#....#.#..#.\",\n\"#..........#.....................#.........##..........#.....................#.........##..........#.........#.\",\n\"###..#.....##############..#.....##############..#.x...##############..#.....#########.####..#.....######..###.\",\n\".........*.....................*......................*........#.#...........*..........#...........*.......#..\",\n\"....#....#.##.#####.#......#....#.##.#####.#......#....#.##.#####.#......#....#.##.#####.#......#....#.##..##..\",\n\"#...#....#..#......*..#...#....#..#......*..#...#....#..#......*...........#..#......*..#...#....#..#......*...\",\n\"#.####...#*##......*.##.####...#*##......*.##.####...#*##......*.##.####...#*##......*.##.####...#*##......*.#.\",\n\"#....#..##.........#.##....#..##.........#.##....#..##.........#.##....#..##.........#.......#..##.........#.#.\",\n\"#....#...#.###.##..####....#...#.###.##..####....#...#.###.##..####....#...#.###.##..####....#...#.###.##..###.\",\n\"#....#.......#..#....##....#.......#..#....##....#.......#..#....##....#.......#..#....##............#..#....#.\",\n\"#....#.......#..#....##....#.......#..#....##....#.......#..#....##....#.......#..#....##....#.......#..#....#.\",\n\"###..#.##########.#######..#.##########.#######..#.##########.#######..#.##########.#######..#.##########.####.\",\n\"#...##.....#....#.#..##...##.....#....#.#..##...##.....#....#.#..##...##.....#....#.#..##...##.....#....#.#..#.\",\n\"#..........#.........##..........#.........##..........#.........##..........#.........##..........#.........#.\",\n\"###..#.....##############..#.....##############..#.....##############..#.....##############..#.....###########.\",\n\"...............................................................................................................\"];\n\n\"\"\"\nLocalizando a posição do jogador ('x') e do destino ('+')\ne inicializa matriz com estimativa de distância D.\n\"\"\"\n\nD = [];\npi = [];\nfor x in range(0, len(G)):\n\tD += [[]];\n\tpi += [[]];\n\tfor y in range(0, len(G[x])):\n\t\tD[x] += [None];\n\t\tpi[x] += [None];\n\t\tif G[x][y] == 'x':\n\t\t\ts = (x, y);\n\t\t\tl = list(G[x]);\n\t\t\tl[y] = '.';\n\t\t\tG[x] = \"\".join(l);\n\t\telif G[x][y] == '+':\n\t\t\tt = (x, y);\n\n\"\"\"\nPossibilidades de movimentação:\n...\n.x.\n...\n\"\"\"\n\ndx = [-1, -1, -1, 0, 0, 1, 1, 1];\ndy = [-1, 0, 1, -1, 1, -1, 0, 1];\n\n\n\"\"\"\nHeurística que estima a distancia para o destino:\n\nH(p, t) = sqrt((p.x - t.x)^2 + (p.y - t.y)^2)\n\nNesse código utilizamos o quadrado da distância euclidiana como estimativa.\n\"\"\"\n\ndef H(s, t):\n\tDx = s[0] - t[0];\n\tDy = s[1] - t[1];\n\treturn sqrt(Dx * Dx + Dy * Dy);\n\ndef dist(s, t):\n\tDx = s[0] - t[0];\n\tDy = s[1] - t[1];\n\treturn sqrt(Dx * Dx + Dy * Dy);\n\n\n\nQ = [];\n\nD[s[0]][s[1]] = 0;\nheappush(Q, (0, s));\n\n\"\"\"\nEnquanto a fila de prioridade não estiver vazia tente verificar se o topo\nda fila é melhor opção de rota para se chegar nos adjascentes. Como o topo\njá é o mínimo, então garante-se que D[u] já está minimizado no momento.\n\"\"\"\nwhile Q:\n\tp = heappop(Q)[1];\n\n\tu = (p[0], p[1]);\n\tux = u[0];\n\tuy = u[1];\n\n\t\"\"\"\n\tComo já chegamos no destino, podemos parar a busca\n\t\"\"\"\n\tif u == t:\n\t\tbreak;\n\n\tfor i in range(0, len(dx)):\n\t\tvx = u[0] + dx[i];\n\t\tvy = u[1] + dy[i];\n\n\t\tv = (vx, vy);\n\n\t\tduv = dist(u, v);\n\t\tif vx > -1 and vx < len(G):\n\t\t\tif vy > -1 and vy < len(G[vx]): \n\t\t\t\tif (D[vx][vy] > D[ux][uy] + duv or D[vx][vy] == None) and G[vx][vy] != '#':\n\t\t\t\t\tD[vx][vy] = D[ux][uy] + duv;\n\t\t\t\t\tpi[vx][vy] = u;\n\t\t\t\t\t\"\"\"\n\t\t\t\t\tA única diferença entre o A* e o dijkstra é o modo como é ordenado a heap.\n\t\t\t\t\tNo caso, ela utiliza a heurítica H que procura colocar no topo os pontos mais\n\t\t\t\t\tpróximos do destino.\n\t\t\t\t\t\"\"\"\n\t\t\t\t\theappush(Q, (D[vx][vy] + H(v, t), v));\n\t\t\n\nif D[t[0]][t[1]] != None:\n\tprint \"A distância entre s e t é: \", D[t[0]][t[1]]; \n\t\"\"\"\n\tDescomente essa linha caso queira ver a sequencia de passos percorrido pelo jogador\n\t\"\"\"\n\timprime_caminho(pi, t);\n\t\"\"\"\n\tDescomente essa linha se quiseres ver o caminho percorrido na grade\n\t\"\"\"\n\t#renderizar_caminho(pi, G, u);\nelse:\n\tprint \"Não existe caminho entre s e t!\"\n\n" }, { "path": "algorithms/ai/hamming.py", "content": "# coding: utf-8\n'''\nHamming Distance\nAutor:\n\tHamming\nColaborador:\n\tAdriano Melo \n\tDayvid Victor \nTipo:\n\tartificial-intelligence\nDescrição:\n\tAlgorítmo para calcular a distância entre vetores com dados categóricos.\nComplexidade: \n\tO(n) - sendo n o tamanho do vetor\nDificuldade:\n\tfácil\nReferências:\n\n'''\n\ndef hamming(a, b):\n\treturn sum([hamming_i(ai, bi) for ai, bi in zip(a,b)])\n\ndef hamming_i(ai, bi):\n\treturn (0 if ai == bi else 1)\n\ndef knn(k, treino, padrao, distancia=lambda a,b: sum([(c-d)**2 for c,d in zip(a,b)])):\n\tk_nearest = sorted([[distancia(pe[:-1], padrao), pe[-1]] for pe in treino])[:k]\n\treturn max(set([e[-1] for e in k_nearest]), key = [e[-1] for e in k_nearest].count)\n\n\n\nif __name__ == '__main__':\n\ttrain = [['gordo', 'baixo', 'devagar', 'golfista'],\n\t\t['magro', 'alto', 'rapido', 'jogador de basquete'],\n\t\t['magro', 'baixo','rapido', 'jogador de futebol'],\n\t\t['gordo', 'alto', 'rapido', 'jogador de futebol americano'],\n\t\t['medio', 'medio', 'rapido', 'jogador de tenis']]\n\t\n\tpadrao = ['magro', 'medio', 'rapido']\n\t\n\tprint knn(1, train, padrao, distancia = hamming)\n\n" }, { "path": "algorithms/ai/knn.py", "content": "# coding: utf-8\n'''\nK-Nearest Neighboor (k-NN)\nAutor:\n Belur V. Dasarathy\nColaborador:\n\tAdriano Melo \n\tDayvid Victor \nTipo:\n artificial-intelligence\nDescrição:\n Algoritmo de aprendizagem baseado em instâncias.\n Uma matriz é dada ao algoritmo contendo vetores e as classes que eles pertencem,\n um vetor não classificado é a segunda entrada do algoritmo. \n A saída é a classe que o vetor não classificado pertence.\nComplexidade: \n O(n * m * k) = O(n)\n n: número de instâncias\n m: tamanho dos vetores\n k: K-primeiros vizinhos\nDificuldade:\n medio\nReferências:\n Belur V. Dasarathy, ed (1991). Nearest Neighbor (NN) Norms: NN Pattern Classification Techniques. ISBN 0-8186-8930-7.\n'''\n\ndef knn(k, treino, padrao, distancia=lambda a,b: sum([(c-d)**2 for c,d in zip(a,b)])):\n\tk_nearest = sorted([[distancia(pe[:-1], padrao), pe[-1]] for pe in treino])[:k]\n\treturn max(set([e[-1] for e in k_nearest]), key = [e[-1] for e in k_nearest].count)\n\ntreino = [\n\t[1,2,3,4,5,6,'classe 1'],\n [1,2,3,3,5,6,'classe 1'],\n [2,3,5,6,7,8,'classe 2'],\n [9,9,9,9,9,9,'classe 3'],\n [9,9,9,9,9,8,'classe 3'],\n [9,9,9,9,9,7,'classe 3']]\n\nprint knn(1, treino, [2,3,4,6,7,8])\nprint knn(3, treino, [2,3,4,6,7,8])\nprint knn(6, treino, [2,3,4,6,7,8])\n\n" }, { "path": "algorithms/bioinformatics/gc_skew_diagram.py", "content": "# coding: utf-8\n\"\"\"\nSkew Diagram\nAutor:\n\nColaborador:\n Guido Luz Percú (guidopercu@gmail.com)\nTipo:\n bioinformatics\nDescrição:\n Monta os pontos de um diagrama GC Skew, um diagrama que mostra a diferença entre G (guanina) e C (citosina) em um DNA.\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n https://en.wikipedia.org/wiki/GC_skew\nLicenca:\n MIT\n\"\"\"\n\ndef gc_skew_diagram(genome):\n qtd_c = 0\n qtd_g = 0\n skew = [0]\n for base in genome:\n if base == 'C':\n qtd_c += 1\n elif base == 'G':\n qtd_g += 1\n skew.append(qtd_g - qtd_c)\n return skew\n\nprint(gc_skew_diagram('ACCCCGTACTGGGGG'))\n" }, { "path": "algorithms/bioinformatics/reverse_complement.py", "content": "# coding: utf-8\n\"\"\"\nReverse Complement\nAutor:\n\nColaborador:\n Guido Luz Percú (guidopercu@gmail.com)\nTipo:\n bioinformatics\nDescrição:\n 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.\nComplexidade:\n ?\nDificuldade:\n facil\nLicenca:\n MIT\n\"\"\"\n\n\ndef reverse_complement(genoma):\n dicionario = {\"A\": \"T\", \"T\": \"A\", \"C\": \"G\", \"G\": \"C\"}\n complemento_reverso = [dicionario[x] for x in genoma[::-1]]\n return \"\".join(complemento_reverso)\n\nprint(reverse_complement('ATCG')) # CGAT\n" }, { "path": "algorithms/bioinformatics/traducao.py", "content": "# coding: utf-8\n\"\"\"\nTradução\nAutor:\n\nColaborador:\n Guido Luz Percú (guidopercu@gmail.com)\nTipo:\n bioinformatics\nDescrição:\n\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n https://pt.wikipedia.org/wiki/Tradu%C3%A7%C3%A3o_%28gen%C3%A9tica%29\n https://en.wikipedia.org/wiki/Genetic_code\nLicenca:\n MIT\n\"\"\"\n\n\ndef traducao(rna):\n assert len(rna) % 3 == 0\n resultado = ''\n codigo_genetico = {\n 'UUC': 'F', 'CUC': 'L', 'AUC': 'I', 'GUC': 'V', 'UUU': 'F', 'CUU': 'L', 'AUU': 'I', 'GUU': 'V', 'UUA': 'L',\n 'CUA': 'L', 'AUA': 'I', 'GUA': 'V', 'UUG': 'L', 'CUG': 'L', 'AUG': 'M', 'GUG': 'V', 'UCU': 'S', 'CCU': 'P',\n 'ACU': 'T', 'GCU': 'A', 'UCC': 'S', 'CCC': 'P', 'ACC': 'T', 'GCC': 'A', 'UCA': 'S', 'CCA': 'P', 'ACA': 'T',\n 'GCA': 'A', 'UCG': 'S', 'CCG': 'P', 'ACG': 'T', 'GCG': 'A', 'UAU': 'Y', 'CAU': 'H', 'AAU': 'N', 'GAU': 'D',\n 'UAC': 'Y', 'CAC': 'H', 'AAC': 'N', 'GAC': 'D', 'UAA': '', 'CAA': 'Q', 'AAA': 'K', 'GAA': 'E', 'UAG': '',\n 'CAG': 'Q', 'AAG': 'K', 'GAG': 'E', 'UGU': 'C', 'CGU': 'R', 'AGU': 'S', 'GGU': 'G', 'UGC': 'C', 'CGC': 'R',\n 'AGC': 'S', 'GGC': 'G', 'UGA': '', 'CGA': 'R', 'AGA': 'R', 'GGA': 'G', 'UGG': 'W', 'CGG': 'R', 'AGG': 'R',\n 'GGG': 'G',\n }\n for i in range(0, len(rna), 3):\n traducao = codigo_genetico[rna[i:i+3]]\n if traducao != '':\n resultado +=traducao\n return resultado\nprint(traducao('ACGUUA'))\n" }, { "path": "algorithms/bioinformatics/transcricao.py", "content": "# coding: utf-8\n\"\"\"\nTranscrição\nAutor:\n\nColaborador:\n Guido Luz Percú (guidopercu@gmail.com)\nTipo:\n bioinformatics\nDescrição:\n Transcrição é o processo de formação do RNAm mensageiro a partir da cadeia-molde de DNA\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n https://pt.wikipedia.org/wiki/Transcri%C3%A7%C3%A3o_%28gen%C3%A9tica%29\nLicenca:\n MIT\n\"\"\"\ndef transcrever(dna):\n \"\"\" Transforma string DNA em string RNAm \"\"\"\n return dna.replace('T', 'U')\n\nprint(transcrever('ACGT'))\n" }, { "path": "algorithms/color/rgb-to-cmyk.py", "content": "# encoding: utf-8\n\n'''\nRGB to CMYK\nAutor:\n ?\nColaborador:\n Aurélio A. Heckert\nTipo:\n color\nDescrição:\n Converte uma cor definida em RGB para CMYK.\n\n RGB é um sistema aditivo de definição de cores, representa a mistura de luz. Suas componentes são (em ordem) vermelho, verde e azul.\n 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.\n 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).\nComplexidade: \n O(1)\nDIficuldade:\n facil\nReferências:\n http://en.wikipedia.org/wiki/RGB\n http://en.wikipedia.org/wiki/CMYK\n'''\n\ndef rgb2cmyk( red, green, blue ):\n\n black = min( 1-red, 1-green, 1-blue )\n nb = 1 - black # negative black\n if black == 1:\n cyan = 0\n magenta = 0\n yellow = 0\n elif nb > 0:\n cyan = ( nb - red ) / nb\n magenta = ( nb - green ) / nb\n yellow = ( nb - blue ) / nb\n else:\n cyan = 1 - red\n magenta = 1 - green\n yellow = 1 - blue\n\n return \"%.1f %.1f %.1f %.1f\" % ( cyan, magenta, yellow, black )\n\n\nprint 'Preto:\\t\\t\\t', rgb2cmyk( 0.0, 0.0, 0.0 )\nprint 'Cinza escuro:\\t\\t', rgb2cmyk( 0.3, 0.3, 0.3 )\nprint 'Cinza médio:\\t\\t', rgb2cmyk( 0.5, 0.5, 0.5 )\nprint 'Cinza claro:\\t\\t', rgb2cmyk( 0.7, 0.7, 0.7 )\nprint 'Branco:\\t\\t\\t', rgb2cmyk( 1.0, 1.0, 1.0 )\nprint 'Vermelho vivo:\\t\\t', rgb2cmyk( 1.0, 0.0, 0.0 )\nprint 'Vermelho sangue:\\t', rgb2cmyk( 0.7, 0.0, 0.0 )\nprint 'Laranja:\\t\\t', rgb2cmyk( 1.0, 0.5, 0.0 )\nprint 'Verde Musgo:\\t\\t', rgb2cmyk( 0.6, 0.7, 0.6 )\n" }, { "path": "algorithms/combinatory/derangement.py", "content": "#!usr/bin/python\n# encoding: utf-8\n\n\"\"\"\nDesarranjo\nAutor:\n Pierre Raymond de Montmort\nColaborador:\n Carlos Rodrigues c11a10r9l8o7s6f5e4l3i2x1@yahoo.com.br\nTipo:\n math\nDescrição:\n Algoritmo que calcula permutação caótica\nDificuldade:\n facil\nComplexidade:\n ?\nReferência:\n http://pt.wikipedia.org/wiki/Desarranjo\n\"\"\"\n\nfrom __future__ import division\n\ndef fatorial(x):\n if x <= 1:\n return 1\n else:\n return x * fatorial(x-1)\n\nn = 5\nd = 0\nfor i in range(0, n):\n d = d + ((-1) ** i / fatorial(i))\nprint fatorial(n) * d\n" }, { "path": "algorithms/crypto/cesar.py", "content": "#!/usr/bin/env python\n# -*- encoding: utf-8 -*-\n\n\"\"\"\nCesar Cipher (Cifra de César)\nAutor:\n César\nColaborador:\n Apu, Sigano, InFog, Paulo, Doug, ExHora \nTipo:\n crypto\nDescrição:\n Este algoritmo implementa a Cifra de César\n Este algoritmo foi implementado em um Dojo do Grupo de Compartilhamento do\n Conhecimento Santos Dumont \nComplexidade: \n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Cifra_de_C%C3%A9sar\nLicenca:\n GPL\n\"\"\"\n\n__authors__ = (\n \"Apu\",\n \"Sigano\",\n \"InFog\",\n \"Paulo\",\n \"Doug\",\n \"ExHora\"\n)\n\nimport string\n\nclass Cesar(object): \n \n def __init__(self):\n self.INICIO = 65\n self.FIM = 90\n self.ESPACO = 32\n \n def crypt(self, entrada = \"\", chave = 0):\n saida = \"\"\n entrada = entrada.upper()\n\n for letra in entrada:\n valor = ord(letra)\n \n if (not valor == self.ESPACO):\n valor += chave\n if (valor > self.FIM):\n valor -= 26\n saida += chr(valor)\n \n return saida\n \n def decrypt(self, entrada = \"\", chave = 0):\n saida = \"\"\n entrada = entrada.upper()\n \n for letra in entrada:\n valor = ord(letra)\n \n if (not valor == self.ESPACO):\n valor -= chave\n if (valor < self.INICIO):\n valor += 26\n saida += chr(valor)\n \n return saida\n\nc = Cesar()\nprint c.crypt(\"a ligeira raposa marrom saltou sobre o cachorro cansado\", 3)\nprint c.decrypt(\"D OLJHLUD UDSRVD PDUURP VDOWRX VREUH R FDFKRUUR FDQVDGR\", 3)\n" }, { "path": "algorithms/crypto/rot13.py", "content": "#!/usr/bin/env python3.1\n\n\"\"\"\nROT13\nAutor:\n ?\nColaborador:\n Fernando Medeiros \nTipo:\n sequence\nDescrição: \n Implementação do algoritmo ROT-13, ou \"Rotate By 13\".\n É um procedimento simples mas eficaz para garantir que textos eletrônicos \n não sejam lidos por distração ou acidente.\n Util para proteger mensagens que talvez o leitor não queira ler. \n Exemplo, \"spoilers\" sobre determinado assunto em Fóruns ou listas de discussão.\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/ROT13\n\"\"\"\n\ndef rot13(text):\n alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'\n rotated = 'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm'\n r13 = \"\".maketrans(alpha, rotated)\n return text.translate(r13)\n\n#Exemplos de uso:\n\nprint(rot13(\"Agora estou usando ROT-13!\"))\n#Exibe a mensagem: Ntben rfgbh hfnaqb EBG-13!\n\nprint(rot13(\"Ntben rfgbh hfnaqb EBG-13!\"))\n#Exibe a mensagem: Agora estou usando ROT-13!\n#Note que a mesma função é usada para codificar e decodificar o texto.\n" }, { "path": "algorithms/crypto/rsa.py", "content": "#!/usr/bin/python\n# -*- coding: iso-8859-1 -*-\n\"\"\"\nRSA\nAutor:\n Ron Rivest, Adi Shamir, e Leonard Adleman \nColaborador:\n Juan Lopes \nTipo:\n crypto\nDescrio: \n Implementao simples do algoritmo RSA.\n \n Este algoritmo se baseia na dificuldade computacional da fatorao de\n nmeros inteiros.\n \n A idia que a chave pblica e privada sejam baseadas na multiplicao\n de dois nmeros primos (geralmente grandes) e que a relao entre elas\n exija o conhecimento dos fatores dessa multiplicao.\nComplexidade:\n O(n)\nDificuldade:\n medio\nReferncias:\n http://en.wikipedia.org/wiki/RSA_(algorithm)\n\"\"\"\n\ndef gcd(a,b):\n if b==0: return (1, 0)\n q = a/b\n x,y = gcd(b, a-q*b)\n return (y, x-q*y)\n \ndef inverse(a, b):\n x,y = gcd(a,b)\n return (x if x > 0 else x+b)\n \ndef rsa(n, e, M):\n return map(lambda m: pow(m, e, n), M)\n \np,q = 41, 47 #primos \nn,phi = p*q, (p-1)*(q-1) #mdulo and totiente\ne,d = 7, inverse(7,phi) #expoentes pblico e privado\n\nplain = (1,2,3,4,5,6,7,42)\nencrypted = rsa(n, e, plain)\nplain_again = rsa(n, d, encrypted)\n\nprint 'Chave pblica:', (n,e)\nprint 'Chave privada:', (n,d)\nprint '---'\nprint 'Mensagem original:', plain\nprint 'Mensagem encriptada:', encrypted\nprint 'Mensagem decriptada:', plain_again" }, { "path": "algorithms/crypto/vigenere.py", "content": "#!usr/bin/python\n# encoding: utf-8\n\n\"\"\"\nVigenère cipher (Cifra de Vigenère)\nAutor:\n Giovan Battista Bellaso (1553) \"La cifra del. Sig. Giovan Battista Bellaso\"\n Foi erradamente atribuida a Blaise de Vigenère\nColaborador:\n damor - dave-world (at) hotmail.com\nTipo:\n Crypto\nDescrição:\n Este algoritmo implementa o metodo de criptografia \"Cifra de Vigenère\"\n \"A cifra de Vigenère consiste no uso de várias cifras de César em sequência,\n com diferentes valores de deslocamento ditados por uma \"palavra-chave\"\" - Wiki\nComplexidade:\n ?\nDificuldade:\n facil\nReferências: (opcional)\n http://pt.wikipedia.org/wiki/Cifra_de_Vigen%C3%A8re\nLicenca:(opcional)\n GPL\n\"\"\"\n\nclass Vigenere(object):\n def __init__(self):\n self.tabulaRecta = [ [ 0 for i in range(26) ] for j in range(26) ] # Construir a tabula recta (Grelha de Vigenere)\n for i in range(26):\n for j in range(26):\n ch = ord(\"A\")+j+i\n if (ch>90): ch-=26\n self.tabulaRecta[i][j] = chr(ch)\n\n def crypt(self, plaintext = \"\", chave= \"\"):\n self.newKey=chave\n while len(self.newKey) 0 else None)\n\n def push(self, value):\n self.V.append(value)\n self.bubble_up(self.count())\n \n def pop(self):\n if self.count() == 0: return None\n \n value = self.V[1]\n self.V[1] = self.V[-1]\n self.V.pop()\n self.bubble_down(1)\n return value\n \n def pop_all(self):\n while self.count() > 0:\n yield self.pop()\n \n def bubble_up(self, n):\n while n != 1 and self.less(n, n/2):\n self.swap(n, n/2)\n n /= 2\n \n def bubble_down(self, n):\n while self.less(n*2, n) or self.less(n*2+1, n):\n c = self.min(n*2, n*2+1)\n self.swap(n, c)\n n = c\n\n def less(self, a, b):\n if a>self.count(): return False\n if b>self.count(): return True\n return self.V[a]', list(BinaryHeap(V).pop_all())\n" }, { "path": "algorithms/data-structures/stack.py", "content": "\n\"\"\"\nStack\nAutor:\n ?\nColaborador:\n Guido Luz Percú (guidopercu@gmail.com)\nTipo:\n data-structures\nDescrição:\n Implementação da estrutura de dados Stack, uma coleção de elementos com duas\n operações principais: push e pop. Também conhecida por LIFO (last in, first\n out).\nComplexidade:\n ?\nDificuldade:\n facil\nReferências: (opcional)\n http://www.wikiwand.com/en/Stack_%28abstract_data_type%29\n\"\"\"\n\n\nclass Stack:\n def __init__(self):\n self._stack = []\n\n def __len__(self):\n return len(self._stack)\n\n def __str__(self):\n return \"{}\".format(self._stack)\n\n def top(self):\n return self._stack[-1]\n\n def push(self, value):\n self._stack.append(value)\n\n def pop(self):\n self._stack.pop()\n\n\nif __name__ == \"__main__\":\n pilha = Stack()\n pilha.push(1)\n pilha.push(2)\n pilha.push(3)\n print(pilha)\n print(pilha.top())\n print(\"Tamanho da pilha: {}\".format(len(pilha)))\n\n pilha.pop()\n print(pilha)\n print(\"Tamanho da pilha: {}\".format(len(pilha)))\n print(pilha.top())\n" }, { "path": "algorithms/date/leap-year.py", "content": "# -*- encoding: utf-8 -*-\n\"\"\"\nBissexto\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n date\nDescrição:\n Calcula os próximos anos bissextos\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Ano_bissexto#Calend.C3.A1rio_Gregoriano\n\n\"\"\"\n\nfrom datetime import datetime\n\ndef anoBissexto(anos):\n\tanoAtual = datetime.now().year\n\tproximoAno = anoAtual + anos\n\tfor ano in range(anoAtual,proximoAno):\n\t\tif ano % 4 == 0 and (ano % 100 or ano % 400 == 0):\n\t\t\tyield ano\n\nfor ano in anoBissexto(100): print ano\n" }, { "path": "algorithms/economics/financiamento.py", "content": "# -*- encoding: utf-8 -*-\n\n\"\"\"\nFinanciamento\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n ?\nDescrição:\n\tCalcula o valor das parcelas do financiamneto\n\tbaseado no capital inicial e taxa de juros\n\tde acordo na função Price\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Tabela_price#C.C3.A1lculo\n\"\"\"\n\ndef parcelas(investimento, juros, periodo):\n\treturn (investimento*juros) / (1 - (1/(1+juros)**periodo))\n\t\nprint parcelas(1000, 0.03, 4)\n" }, { "path": "algorithms/geography/haversine.py", "content": "# -*- encoding: utf-8 -*-\n\"\"\"\nHaversine\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n geography\nDescrição:\n Calcula a distancia mais curta\n entre dois pontos com latitude e longitude\n na superficie da Terra\n usando a formula de haversine\nComplexidade:\n ?\nDificuldade:\n medio\nReferências:\n http://en.wikipedia.org/wiki/Haversine_formula\n\n\"\"\"\nfrom __future__ import division\nimport math\n\n\ndef strTodegree(string):\n grau, minuto, segundo = [int(x) for x in string.split()]\n if(string.find(\"-\") == -1):\n grau += (minuto/60) + (segundo/3600)\n else:\n grau -= (minuto/60) + (segundo/3600)\n return grau\n\n\ndef haversin(theta):\n\treturn math.sin(theta/2)**2\n\n\ndef distancia(latitude1, longitude1, latitude2, longitude2):\n\tRadius = 6371 #Terra\n\tdeltaLatitude = math.radians(latitude2 - latitude1)\n\tdeltaLongitude = math.radians(longitude2 - longitude1)\n\th = haversin(deltaLatitude) + math.cos(math.radians(latitude1))*math.cos(math.radians(latitude2))*haversin(deltaLongitude)\n\treturn 2*Radius*math.asin(math.sqrt(h))\n\nprint distancia(strTodegree(\"53 08 50\"),strTodegree(\"-01 50 58\"),strTodegree(\"52 12 16\"),strTodegree(\"00 08 26\"))\n" }, { "path": "algorithms/graphs/BellmanFord.py", "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo de Bellman-Ford.\n\nAutor:\n\tRichard Bellman & Lester R. Ford Jr. (1958)\n\nColaborador:\n\tPedro Arthur Duarte (JEdi)\n\tpedroarthur.jedi@gmail.com\n\nTipo:\n\tgraph\n\tshortest path on directed graphs with negative weighted edges\n\nDescrição:\n\tO algoritmo de Bellman-Ford determina o caminho mais curto de origem única\n\tem grafos com arestas de pesos negativos. Para grafos sem arestas negativas,\n\to algoritmo de Dijkstra apresenta melhor desempenho.\n\nComplexidade:\n\tO(V*E), onde 'V' é a cardinalidade o conjunto de vértices e 'E' a\n\tcardinalidade do conjunto de arestas.\n\nDificuldade:\n\tmedia\n\nReferências:\n\thttp://en.wikipedia.org/wiki/Bellman-Ford_algorithm\n\nLicença:\n\tGPLv3\n\n\"\"\"\n\nfrom sys import maxint\n\nclass NegativeWeightCycleError(Exception):\n\tpass\n\n\nclass Vertex:\n\t'''\n\tAbstração de vértice para a implementação através de lista de adjacência;\n\testão inclusos atributos extras para a implementação do algoritmo\n\t'''\n\tdef __init__(self, label, distance, predecessors=None):\n\t\tself.label = label\n\n\t\tself.distance = distance\n\t\tself.predescessor = None\n\n\tdef __repr__(self):\n\t\treturn str(self.label)\n\nclass Edge:\n\t'''\n\tAbstração de aresta para a implementação através de lista de adjacência\n\t'''\n\tdef __init__(self, source, destination, weight):\n\t\tself.src = source\n\t\tself.dst = destination\n\t\tself.wht = weight\n\nclass Graph:\n\t'''\n\tAbstração de grafo para a implementação através de lista de adjacência.\n\t'''\n\tdef __init__(self, graph=None):\n\t\t'''\n\t\tCaso seja passada uma matriz de adjacência, essa é transformada numa\n\t\tlista de adjacência.\n\t\t'''\n\t\tself.vertex = { }\n\t\tself.edges = [ ]\n\n\t\tif graph == None:\n\t\t\treturn\n\n\t\tfor i in xrange(0, len(graph)):\n\t\t\tfor j in xrange(0, len(graph)):\n\t\t\t\tif graph[i][j] == None:\n\t\t\t\t\tcontinue\n\n\t\t\t\tself.addEdge(i, j, graph[i][j])\n\n\tdef addEdge(self, source, destination, weight):\n\t\tif source not in self.vertex:\n\t\t\tself.vertex[source] = Vertex(source, maxint)\n\n\t\tif destination not in self.vertex:\n\t\t\tself.vertex[destination] = Vertex(destination, maxint)\n\n\t\tself.edges.append(\n\t\t\tEdge(self.vertex[source], self.vertex[destination], weight))\n\nclass BellmanFord:\n\tdef __init__(self, g):\n\t\tself.graph = g\n\n\tdef adjacencyMatrixShortestPath(self, source, destination):\n\t\t'''Implementação através de matriz de adjacência'''\n\n\t\t# Etapa de inicialização: todas as distâncias são definidas como\n\t\t# infinitas para que sejam então atualizadas durante a relaxação\n\t\tself.distances = [ maxint for s in self.graph ]\n\t\tself.distances[source] = 0\n\n\t\t# Arranjo auxiliar para que possamos reconstruir o menor caminho\n\t\tself.predecessors = [ 0 for s in self.graph ]\n\n\t\t# Para cada v em V:\n\t\tfor i in xrange(0, len(self.graph)):\n\t\t\t# Para cada e em E\n\t\t\t#\tAqui, devido ao uso da matriz de adjacência, precisamos\n\t\t\t#\tutilizar dois laços \"para\" (for) de forma que possamos\n\t\t\t#\tpercorrer todas as aresta\n\t\t\tfor u in xrange(0, len(self.graph)):\n\t\t\t\tfor v in xrange(0, len(self.graph)):\n\t\t\t\t\tif self.graph[u][v] == None:\n\t\t\t\t\t\tcontinue\n\n\t\t\t\t\t# Etapa de \"relaxação\" do grafo\n\t\t\t\t\tif self.distances[u] + self.graph[u][v] < self.distances[v]:\n\t\t\t\t\t\tself.distances[v] = self.distances[u] + self.graph[u][v]\n\t\t\t\t\t\tself.predecessors[v] = u\n\n\t\t# Verificação da existência de círculos negativos\n\t\tfor u in xrange(0, len(self.graph)):\n\t\t\tfor v in xrange(0, len(self.graph)):\n\t\t\t\tif self.graph[u][v] == None:\n\t\t\t\t\tcontinue\n\n\t\t\t\tif self.distances[u] + self.graph[u][v] < self.distances[v]:\n\t\t\t\t\traise NegativeWeightCycleError\n\n\t\t# lista de saída; índice -1 indica o custo total do menor caminho\n\t\toutput = [ self.distances[destination] ]\n\n\t\t# Reconstruindo o menor caminho através do predecessor do destino\n\t\twhile True:\n\t\t\toutput.insert(0, destination)\n\n\t\t\tif destination == source:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tdestination = self.predecessors[destination]\n\n\t\t# Crianças, não façam isso em casa.\n\t\treturn output[:-1], output[-1]\n\n\tdef adjacencytListShortestPath(self, source, destination):\n\t\t'''\n\t\tImplementação através de lista de adjacência;\n\n\t\tFuncionalmente, o mesmo código acima. Porém, bem mais limpo e menos\n\t\tdevorador de memória. Adequado para matrizes esparsas.\n\t\t'''\n\t\t\n\t\tsource, destination = (self.graph.vertex[source],\n\t\t\t\t\t\t\t\tself.graph.vertex[destination])\n\n\t\t# A etapa de inicialização está parcialmente implícita no construtor\n\t\t# da classe Vertex. Assim, precisamos apenas atualizar o valor de\n\t\t# distância do nó origem.\n\t\tsource.distance = 0\n\n\t\tfor _ in self.graph.vertex:\n\t\t\tfor e in self.graph.edges:\n\t\t\t\tif e.src.distance + e.wht < e.dst.distance:\n\t\t\t\t\te.dst.distance = e.src.distance + e.wht\n\t\t\t\t\te.dst.predescessor = e.src\n\n\t\tfor e in self.graph.edges:\n\t\t\tif e.src.distance + e.wht < e.dst.distance:\n\t\t\t\traise NegativeWeightCycleError\n\n\t\toutput = [ destination.distance ]\n\n\t\twhile True:\n\t\t\toutput.insert(0, destination)\n\n\t\t\tif destination == source:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tdestination = destination.predescessor\n\n\t\treturn output[:-1], output[-1]\n\n'''\nMatriz de adjacência; None pode ser utilizado para representar a inexistência\nde arestas entre dois vértices.\n'''\ngraph = [\n\t[7, 6, 8, 3, 5, 3, 2, 7, 1, 2, ],\n\t[0, 5, 2, 9, 1, 6, 2, 9, 9, 7, ],\n\t[6, 8, 7, 5, 8, 5, 7, 9, 8, 2, ],\n\t[6, 9, 7, 5, 8, 9, 8, 6, 3, 4, ],\n\t[0, 4, 8, 1, 6, 5, 8, 0, 7, 9, ],\n\t[2, 3, 3, 9, 9, 0, 0, 3, 0, 4, ],\n\t[7, 8, 0, 7, 7, 2, 9, 6, 0, 8, ],\n\t[3, 3, 5, 4, 8, 8, 8, 4, 4, 0, ],\n\t[9, 7, 2, 5, 0, 5, 4, 9, 0, 3, ],\n\t[6, 1, 8, 6, 6, 6, 1, 6, 7, 9, ],\n]\n\n# Calculando o menor caminho através da matriz\nprint BellmanFord(graph).adjacencyMatrixShortestPath(0,9)\n\n# Calculando o menor caminho através da lista\nprint BellmanFord(Graph(graph)).adjacencytListShortestPath(0,9)\n" }, { "path": "algorithms/graphs/Dijkstra.py", "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo de Dijkstra (com lista de adjascencias)\nAutores: \n Edsger Dijkstra\nColaborador:\n \tPéricles Lopes Machado (pericles.raskolnikoff@gmail.com)\nTipo: \n graphs\nDescrição: \n O Algoritmo de Dijsktra é um algoritmo em grafos clássico que determina a\n menor distância de um determinado vértice para todos os outros. Nessa implementação\n\tutiliza-se uma heap\nComplexidade: \n O(|E| log |V|)\nDificuldade: \n medio\nReferências:\n [1] http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm\n [2] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. \n ISBN 978-0-262-53305-8. Páginas 658-659.\n\"\"\"\n\nfrom heapq import *;\n\n\"\"\"\nFunção para imprimir rota\n\"\"\"\n\ndef imprime_rota(pi, u):\n\tif pi[u] != None:\n\t\timprime_rota(pi, pi[u]);\n\tprint \" \", u;\n\n\"\"\"\nLista de adjacência; Para cada nó 'u' é fornecida uma lista de pares (v, d), onde 'v' é um \nnó que está conectado a 'u' e 'd' é a distancia entre 'u' e 'v'\n\"\"\"\n\nG = [\n\t[(1, 2), (3, 4), (5, 3), (8, 9)], \n\t[(2, 7), (4, 6), (7, 8)],\n\t[(4, 9), (7, 9)],\n\t[(1, 13), (4, 4), (6, 3), (2, 3)], \n\t[(1, 23), (7, 4), (5, 3), (8, 1), (4, 9)], \n\t[(3, 11), (4, 7), (8, 9)], \n\t[(5, 2), (3, 5), (4, 3), (5, 9)], \n\t[(1, 2), (7, 4), (5, 9), (6, 8)], \n\t[(7, 2), (2, 3), (1, 1), (3, 1)], \n]; \n\n\n\"\"\"\nOrigem s e destino t\n\"\"\"\ns = 1;\nt = 6;\n\nN = len(G);\n\n\"\"\"\nEstimativa de distancia inicial\nNone representa o infinito e código pai usado para recuperar a rota\n\"\"\"\nD = [];\npi = [];\n\nfor i in range(0, N):\n\tD += [None];\n\tpi += [None];\n\n\"\"\"\nPriority queue utilizada para o acesso rápido a melhor estimativa\n\"\"\"\nQ = [];\n\nD[s] = 0;\nheappush(Q, (0, s));\n\n\"\"\"\nEnquanto a fila de prioridade não estiver vazia tente verificar se o topo\nda fila é melhor opção de rota para se chegar nos adjascentes. Como o topo\njá é o mínimo, então garante-se que D[u] já está minimizado no momento.\n\"\"\"\nwhile Q:\n\tu = heappop(Q)[1];\n\tfor adj in G[u]:\n\t\tv = adj[0];\n\t\tduv = adj[1];\n\t\tif D[v] > D[u] + duv or D[v] == None:\n\t\t\tD[v] = D[u] + duv;\n\t\t\tpi[v] = u;\n\t\t\theappush(Q, (D[v], v));\n\nif D[t] != None:\n\tprint \"Distância(\", s, \",\", t, \") = \", D[t]; \n\tprint \"Rota:\";\n\timprime_rota(pi, t);\nelse:\n\tprint \"Não há rota entre os nós \", s, \" e \", t;\n\n\n" }, { "path": "algorithms/graphs/EdmondsKarp.py", "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo de Edmonds-Karp.\n\nAutor:\n Jack Edmonds & Richard Karp (1972)\n\nColaborador:\n Pedro Arthur Duarte (JEdi)\n pedroarthur.jedi@gmail.com\n\nTipo:\n graph\n\nDescrição:\n O Algoritmo de Edmonds-Karp é uma implementação do método de Ford-Fulkerson\n para o cálculo do fluxo máximo em uma rede de fluxos. Esse algoritmo é\n idêntico ao método de Ford-Fulkerson excetuando-se no critério que utiliza\n para a escolha do caminho aumentante: o caminho precisa ser o menor caminho\n que possibilita o aumento do fluxo.\n\nComplexidade:\n O(V*E²), onde 'V' é a cardinalidade o conjunto de vértices e 'E' a\n cardinalidade do conjunto de arestas.\n\nDificuldade:\n alta (?)\n\nReferências:\n http://en.wikipedia.org/wiki/Edmonds\n\nLicença:\n GPLv3\n\n\"\"\"\n\n# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #\nfrom sys import stdin;\n\nDIMACS = 0\nWFLOW = 1\nRAW = 2\n\nIMPERATIVE = 0\nFUNCTIONAL = 1\n\nclass EdmondsKarp:\n # Cria nova instância da classe.\n # Parâmetros:\n # c: matriz de fluxos (f[i,j] = c[i][j])\n # s: vértice do qual se origina o fluxo;\n # t: vértice de destino do fluxo;\n def __init__(self, c, s, t):\n self.c = c\n self.s = s\n self.t = t\n\n # Matriz auxiliar dos fluxos\n self.f = [[0] * len(i) for i in c]\n\n #print c\n\n # Iterador para auxiliar na construção da resposta\n def __iter__(self):\n return self\n\n # Busca primeiro em largura:\n def next(self):\n q = [ self.s ]\n p = { self.s: [] }\n\n # Critério: capacidade(e) - fluxoatual(e) > 0\n\n # Implementação imperativa (aquela que se encontra geralmente nos livros)\n if self.approach == IMPERATIVE:\n for u in q:\n for v in xrange(len(self.c)):\n if self.c[u][v] - self.f[u][v] > 0 and v not in p:\n p[v] = p[u] + [(u,v)]\n if v == self.t:\n return p[v]\n q.append(v)\n\n # Implementação por meio de diretivas funcionais. Bonito, mas impraticável\n # para grandes instâncias desse problema.\n else:\n fcond = (lambda x: x[0][1] - x[1] > 0 and x[0][0] not in p)\n for u in q:\n for v in map(\n lambda x: x[0][0],\n filter(fcond, zip(enumerate(self.c[u]), self.f[u]))):\n p[v] = p[u] + [(u,v)]\n if v == self.t:\n return p[v]\n q.append(v)\n\n raise StopIteration\n\n # Esse algoritmo também é capaz de determinar o corte mínimo.\n # Esse método faz isso :-)\n def MinCutVertex(self):\n q = [ self.s ]\n o = [ ]\n\n for u in q:\n for v in xrange(len(self.c)):\n if self.c[u][v] - self.f[u][v] > 0 and v not in o:\n o.append(v)\n q.append(v)\n\n return o\n\n # Retorna a matriz de fluxos\n def FlowEdges(self, outtype=RAW):\n # Retorna a própria matriz de fluxos\n if outtype == RAW:\n return self\n\n # seleciona apenas os vértices que possuem algum fluxo\n if outtype == WFLOW:\n q = [ self.s ]\n p = []\n u = 0\n\n fcond =\n\n for u in q:\n f = map(\n lambda x: x[0][0],\n filter(\n lambda x:x[1]>0 and (u,x[0][0],self.f[u][x[0][0]]) not in p,\n zip(enumerate(self.c[u]), self.f[u])\n )\n )\n for v in f:\n p = p + [(u,v,self.f[u][v])]\n q.append(v)\n\n return p\n\n # retorna nada =p\n else:\n return [ ]\n\n # Implementação do algoritmo de Edmonds-Karp\n def MaxFlow(self, approach=IMPERATIVE):\n self.approach = approach\n\n # Enquanto houverem caminhos aumentantes,\n # selecione aquele de menor custo;\n for p in self:\n\n # Dentro desse caminho, encontre a aresta\n # que possuí menor capacidade de vazão:\n mf = min(map(lambda e: self.c[e[0]][e[1]] - self.f[e[0]][e[1]], p))\n\n # Ajuste os valores da matriz de fluxo de\n # acordo com o vazão da aresta encontrada\n # no passo anterior\n for u,v in p:\n self.f[u][v] += mf\n self.f[v][u] -= mf\n\n # Retorna o fluxo máximo\n return sum(self.f[self.s])\n\n" }, { "path": "algorithms/graphs/FloydWarshall.py", "content": " \n# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo de Floyd-Warshall.\n\nAutor:\n\tRobert W. Floyd & Stephen Warshall (1962)\n\nColaborador:\n\tPedro Arthur Duarte (JEdi)\n\tpedroarthur.jedi@gmail.com\n\nTipo:\n\tgraph\n\tall-pairs shortest path in weighted graphs\n\tdynamic programming\n\nDescrição:\n\tO algoritmo de Floyd-Warshall computa os caminhos mais curtos entre todos os pares de um grafo valorado de pesos arbitrários.\n\n\tA formulação em programação dinâmica para esse problema consiste em\n\tdeterminar de forma bottom-up os menores caminhos para todos os vértices\n\tconsiderando que os caminhos intermediários consistem apenas de um\n\tsubconjunto de vértices. Assim, $d_{ij}^{(k)}$ é menor caminho do vértice\n\t$i$ ao vértice $j$ tal que esse caminho consiste apenas de vértices\n\tintermediários em $k$. Assim, a seguinte formulação é empregada no\n\talgoritmo de Floyd-Warshall:\n\n\t$$ d_{ij}^{(k)} = min(d_{ij}^{(k)}, d_{ik}^{(k-1)} + d_{kj}^{(k-1)}) $$\n\n\tEssa formulação assuma que $d_{ij} = 0$ se $i=j$, e $d_{ij}=\\infty$ se não\n\thá uma aresta entre os vértices $i$ e $j$.\n\nComplexidade:\n\tΘ(V³), onde 'V' é a cardinalidade o conjunto de vértices.\n\nDificuldade:\n\tmédia\n\nReferências:\n\tCormen; Leiserson; Rivest; Stein. Introduction to Algorithms (2 ed). ISBN: 978-0262033848.\n\thttps://secure.wikimedia.org/wikipedia/en/wiki/Floyd–Warshall_algorithm\n\nLicença:\n GPLv3\n\n\"\"\"\n\nfrom sys import maxint as Infinity\n\nclass NoSuchAPathError(Exception):\n\tpass\n\nclass FloydWarshall:\n\tdef __init__(self, matrix):\n\t\tself.matrix = [ ]\n\t\tself.paths = [ ]\n\n\t\tfor r in matrix:\n\t\t\tself.matrix.append([ ])\n\t\t\tself.paths.append([ ])\n\n\t\t\tfor c in r:\n\t\t\t\tself.matrix[-1].append(c)\n\t\t\t\tself.paths[-1].append(None)\n\n\tdef shortestPaths(self):\n\t\tfor k in xrange(0, len(self.matrix)):\n\t\t\tfor i in xrange(0, len(self.matrix)):\n\t\t\t\tfor j in xrange(0, len(self.matrix)):\n\t\t\t\t\tif self.matrix[i][k] + self.matrix[k][j] < self.matrix[i][j]:\n\t\t\t\t\t\tself.matrix[i][j] = self.matrix[i][k] + self.matrix[k][j]\n\t\t\t\t\t\tself.paths[i][j] = k\n\n\t\treturn self\n\n\tdef getItermediate(self, source, destination):\n\t\tif self.matrix[source][destination] == Infinity:\n\t\t\traise NoSuchAPathError\n\n\t\tintermediate = self.paths[source][destination]\n\n\t\tif intermediate is None:\n\t\t\treturn [ ]\n\n\t\treturn (self.getItermediate(source, intermediate)\n\t\t\t\t\t+ [ intermediate ]\n\t\t\t\t\t\t+ self.getItermediate(intermediate, destination))\n\n\tdef getPath(self, source, destination):\n\t\treturn ([ source ]\n\t\t\t\t\t+ self.getItermediate(source, destination)\n\t\t\t\t\t\t+ [ destination ])\n\ngraph = [\n\t[0, 6, 8, 3, 5, 3, 2, 7, 1, 2, ],\n\t[0, 0, 2, 9, 1, 6, 2, 9, 9, 7, ],\n\t[6, 8, 0, 5, 8, 5, 7, 9, 8, 2, ],\n\t[6, 9, 7, 0, 8, 9, 8, 6, 3, 4, ],\n\t[0, 4, 8, 1, 0, 5, 8, 0, 7, 9, ],\n\t[2, 3, 3, 9, 9, 0, 0, 3, 0, 4, ],\n\t[7, 8, 0, 7, 7, 2, 0, 6, 0, 8, ],\n\t[3, 3, 5, 4, 8, 8, 8, 0, 4, 0, ],\n\t[9, 7, 2, 5, 0, 5, 4, 9, 0, 3, ],\n\t[6, 1, 8, 6, 6, 6, 1, 6, 7, 0, ],\n]\n\nprint FloydWarshall(graph).shortestPaths().getPath(1,9)\n" }, { "path": "algorithms/math/algebra/bhaskara.py", "content": "# encoding: utf-8\n\n\"\"\"\nBhaskara\nAutor:\n Bhaskara Akaria [1]\nColaborador:\n Karlisson Bezerra\nTipo:\n math\nDescrição:\n Calcula as raízes de uma equação de segundo grau\nComplexidade: \n O(1)\nDIficuldade:\n facil\nReferências:\n [1] http://pt.wikipedia.org/wiki/Bhaskara_Akaria\n\"\"\"\n\nimport math\n\ndef bhaskara(a, b, c):\n delta = b ** 2 - 4 * a * c\n if delta < 0:\n return None\n else:\n raizes = []\n m1 = math.sqrt(delta)\n r1 =(-b + m1) / (2 * a)\n raizes.append(r1)\n r2 =(-b - m1) / (2 * a)\n raizes.append(r2)\n return raizes\n\nprint(bhaskara(1, -1, -2))\n" }, { "path": "algorithms/math/algebra/dda.py", "content": "'''\r\nDDA (Digital Differential Analyzer)\r\nAutor:\r\n ?\r\nColaborador:\r\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\r\nTipo:\r\n\tmath\r\nDescrio:\r\n DDA um algoritmo de interpolao linear entre dois pontos, inicial e final.\r\n\tEle muito usado na rea de Computao Grfica para rasterizar linhas e polgonos.\r\nComplexidade: \r\n O(n)\r\nDificuldade:\r\n facil\r\nReferncias:\r\n http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf\r\n\thttp://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm)\r\n'''\r\n\r\nimport math\r\n\r\ndef DDA(x1, y1, x2, y2):\r\n\t\r\n\tpoints = [] #Guardar os pontos criados na forma (x, y)\r\n\t\r\n\tif (math.fabs(x2 - x1) >= math.fabs(y2 - y1)):\r\n\t\t\r\n\t\tlen = math.fabs(x2 - x1)\r\n\telse:\r\n\t\t\r\n\t\tlen = math.fabs(y2 - y1)\r\n\t\r\n\tdeltax = (x2 - x1) / len\r\n\tdeltay = (y2 - y1) / len\r\n\tx = x1 + math.copysign(0.5, deltax)\r\n\ty = y1 + math.copysign(0.5, deltay)\r\n\t\r\n\tfor i in range(int(len)) :\r\n\t\r\n\t\tpoints.append((math.floor(x), math.floor(y)))\r\n\t\tx += deltax\r\n\t\ty += deltay\r\n\t\r\n\tpoints.append((math.floor(x), math.floor(y)))\r\n\t\r\n\treturn points\r\n\r\nif __name__ == \"__main__\" :\r\n\t\r\n\tprint DDA(-1, -1, 12, 9)" }, { "path": "algorithms/math/algebra/media-num.py", "content": "# -*- encoding: utf-8 -*-\n\n\"\"\"\nMedia Numerica\nAutor:\n ?\nColaborador:\n\tBruno Lara Tavares \n Guilherme Carlos (@guiessence)\nTipo:\n math\nDescrição:\n Calcula a média de numeros inseridos pelo usuário\nComplexidade: \n 0(1)\nDificuldade:\n facil\n\"\"\"\n\nfrom __future__ import division\n\ndef media(*args):\n\tsum = 0\n\tfor i in args:\n\t\tsum += i\n\treturn sum / len(args)\n\n#Adicione a quantidade de numeros que for preciso\nprint media(2,3,4,10)\n" }, { "path": "algorithms/math/algebra/media.py", "content": "# encoding: utf-8\n\n\"\"\"\nCálculo da média ponderada\nAutor:\n ?\nColaborador:\n Karlisson Bezerra\nTipo:\n math\nDescrição:\n Calcula a média ponderada - é um algoritmo\n comum em qualquer curso de introdução à programação,\n que pode variar de acordo com os pesos.\nComplexidade: \n O(1)\nDificuldade:\n facil\n\"\"\"\n\nimport math\n\ndef media(n1, n2, n3):\n p1, p2, p3 = 4, 5, 6\n return (n1 * p1 + n2 * p2 + n3 * p3) / (p1 + p2 + p3)\n\nprint media(7.0, 8.0, 10.0)\n" }, { "path": "algorithms/math/algebra/permutation.py", "content": "# encoding: utf-8\n\n\"\"\"\nPermutation\nAutor:\n Fabian Stedma\nColaborador:\n Bruno Gabriel dos Santos (bruno.gsantos89@gmail.com)\nTipo:\n math\nDescrição:\n Calcula o número de combinações distintas que são possíveis de serem formadas por um array numérico.\nComplexidade: \n O(n!)\nDificuldade:\n medio\nReferências: \n [1] https://en.wikipedia.org/wiki/Permutation#Algorithms_to_generate_permutations\n\"\"\"\n\ndef permutation(input_data, temp_data, position):\n\tif position == len(input_data):\n\t\tprint ''.join(str(temp_data))\n\telse:\n\t\tfor i in xrange(len(input_data)):\n\t\t\tis_same = False\n\t\t\tfor j in xrange(position):\n\t\t\t\tif temp_data[j] == input_data[i]:\n\t\t\t\t\tis_same = True\n\t\t\tif not is_same:\n\t\t\t\tif len(temp_data) <= i:\n\t\t\t\t\ttemp_data.append(input_data[i])\n\t\t\t\telse:\n\t\t\t\t\ttemp_data[position] = input_data[i]\n\t\t\t\tpermutation(input_data, temp_data, position+1)\n\npermutation([1,2,3], [], 0)\n\n" }, { "path": "algorithms/math/bisection-method.py", "content": "# encoding: utf-8\n\"\"\"\nMétodo da Bisseção\nAutor:\n ?\nColaborador:\n Lucas Andrade (lucasfael@gmail.com)\nTipo:\n math\nDescrição:\n Calcula a raiz aproximada de uma equação polinomial qualquer\n dentro de um intervalo até uma precisão desejada.\nComplexidade: \n O(log n)\nDificuldade:\n facil\nReferências:\n http://www.im.ufrj.br/dmm/projeto/projetoc/precalculo/sala/conteudo/capitulos/cap114.html\n \n\"\"\"\n\nimport math\n\ndef root(function, x0, x1, precision=0.0001):\n x0 *= 1.0\n x1 *= 1.0\n while (math.fabs(x0-x1) > precision):\n fx0 = function(x0)\n fx1 = function(x1)\n if (fx0 * fx1) > 0:\n return\n if fx0 == 0:\n return x0\n if fx1 == 0:\n return x1\n x2 = (x0 + x1) / 2\n fx2 = function(x2)\n if (fx0 * fx2) < 0:\n x1 = x2\n else:\n x0 = x2\n return x0\n\ndef funcao(x):\n return math.pow(x, 3)-(9 * x) + 3\n\nx = root (funcao, 0, 1)\nprint x\n" }, { "path": "algorithms/math/linear-algebra/matrix-transpose.py", "content": "# coding: utf-8\n'''\nTransposição de matrizes\nAutor: \n ?\nColaborador:\n Dayvid Victor (victor.dvro@gmail.com)\nTipo:\n math\nDescrição: \n Calcula a matriz tranposta de uma matriz qualquer, ou seja, a matriz\n resultante da troca das linhas pelas colunas.\nComplexidade de tempo: \n O(m*n)\nDificuldade: \n facil\nReferências:\n http://en.wikipedia.org/wiki/Transpose\n'''\n\ndef get_transpose(matrix):\n\treturn [[c for c in [l[i] for l in matrix]] for i in range(len(matrix[0]))]\n\nif __name__ == '__main__':\n\tmatrix = [[1,1,1],[2,2,2],[3,3,3],[4,4,4],[5,5,5]]\n\tprint matrix\n\tprint get_transpose(matrix)\n\t\n" }, { "path": "algorithms/math/luhn.py", "content": "# coding: utf-8\n'''\nAlgorítimo de Luhn\nAutor:\n Hans Peter Luhn\nColaborador:\n Alberto Chvaicer \nTipo:\n math\nDescrição:\n 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.\nComplexidade de tempo:\n O(n)\nDificuldade:\n media\nReferências:\n https://en.wikipedia.org/wiki/Luhn_algorithm\n'''\ndef luhn_checksum(card_number):\n def digits_of(n):\n return [int(d) for d in str(n)]\n digits = digits_of(card_number)\n odd_digits = digits[-1::-2]\n even_digits = digits[-2::-2]\n checksum = 0\n checksum += sum(odd_digits)\n for d in even_digits:\n checksum += sum(digits_of(d*2))\n return checksum % 10\n\ndef calculate_luhn(partial_card_number):\n check_digit = luhn_checksum(int(partial_card_number) * 10)\n return check_digit if check_digit == 0 else 10 - check_digit\n\nprint 'the check digit of 7992739871 is %d' % (calculate_luhn(7992739871)) # should be 3\n" }, { "path": "algorithms/math/number-theory/bozofactoring.py", "content": "# encoding: utf-8\n\n\"\"\"\nBozo factoring\nAutor:\n Ricardo Bittencourt\nColaborador:\n Ricardo Bittencourt (bluepenguin@gmail.com)\nTipo:\n number-theory\nDescrição:\n Calcula os fatores primos de um numero usando o pior algoritmo conhecido.\nComplexidade: \n O(n^n)\nDificuldade:\n medio\nReferências:\n http://blog.ricbit.com/2010/07/o-algoritmo-mais-lento-do-oeste.html\nLicenca:\n GPL\n\"\"\"\n\nimport itertools\n\ndef factor(n):\n solutions = []\n for f in itertools.product(range(1,1+n),repeat=n):\n if reduce(lambda x,y: x*y, f) == n:\n solutions.append(filter(lambda x:x>1, list(f)))\n solutions.sort(key=len, reverse=True)\n return solutions[0]\n\nprint factor(6)\n" }, { "path": "algorithms/math/number-theory/divisors.py", "content": "# * encoding: UTF-8 *\n\n\"\"\"\nDivisors\nAutor:\n ?\nColaborador:\n ?\nDescricao:\n Mostra os divisores de um número\nComplexidade:\n O(n)\nDificuldade:\n facil\n\"\"\"\n\nn = int(raw_input(\"Digite um numero: \"))\nfor i in range(1, n+1):\n if not n % i:\n print i,\n" }, { "path": "algorithms/math/number-theory/eratosthenes.py", "content": "# -*- encoding: utf-8 -*-\n\"\"\"\nCrivo de Eratóstenes\nAutor:\n Eratóstenes de Cirene\nColaborador:\n Juan Lopes (me@juanlopes.net)\nTipo:\n Exemplos: math\nDescrição:\n Gera array de primalidade de inteiros através de algoritmo com baixa \n complexidade.\nComplexidade: \n O(n loglogn)\nDificuldade:\n Médio\nReferências: (opcional)\n http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes\n\"\"\"\n\nfrom math import sqrt\n\ndef sieve(n):\n P = [True]*n\n P[0] = False\n P[1] = False\n \n for i in xrange(2, int(sqrt(n))):\n if P[i]:\n for j in xrange(i**2, n, i):\n P[j] = False\n return P\n\ndef primes_up_to(n):\n for i, p in enumerate(sieve(n)):\n if p: \n yield i\n \nprint 'Primos ate 20:'\nfor i in primes_up_to(20):\n print i\n\n" }, { "path": "algorithms/math/number-theory/euclid.py", "content": "# encoding: utf-8\n\n\"\"\"\nAlgoritmo de Euclides\nAutor:\n Euclides de Alexandria\nColaborador:\n Liquen \nTipo:\n number-theory\nDescrição:\n Algoritmo de Euclides em sua forma moderna. Computa o máximo\n divisor comum (MDC) entre dois números inteiros. Parte do princípio de\n que o MDC não muda se o menor número for subtraído do maior. [1] [2]\nComplexidade:\n O(n^2), onde n é o número de dígitos da entrada. [3]\n O número de passos é no máximo\n log(max(a, b) * sqrt(5)) / log(phi),\n onde phi = 1.618... é a proporção áurea. [3]\nDificuldade:\n facil\nReferências:\n [1] http://en.wikipedia.org/wiki/Euclidean_algorithm\n [2] http://pt.wikipedia.org/wiki/Algoritmo_de_Euclides\n [3] http://mathworld.wolfram.com/EuclideanAlgorithm.html\n\"\"\"\n\ndef euclides(a, b):\n while b != 0:\n a, b = b, a % b\n return a\n\nprint(euclides(1071, 462))\n" }, { "path": "algorithms/math/number-theory/fatorial.py", "content": "# encoding: utf-8\n\n\"\"\"\nCálculo de fatorial\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n math\nDescrição:\n Calcula o fatorial de um número\nComplexidade: \n ?\nDificuldade:\n facil\n\"\"\"\n\n\ndef fatorial(b):\n\treturn 1 if b <= 1 else b*fatorial(b-1)\n\nprint fatorial(6)\n" }, { "path": "algorithms/math/number-theory/fibonacci-matrix-form.py", "content": "# coding: utf-8\n\"\"\"\n * Sequência de Fibonacci\n *\n * Autor:\n * Antonio Ribeiro \n * Tipo:\n * math\n * Descrição:\n * Na matemática, os Números de Fibonacci são uma sequência definida como recursiva.\n * O algoritmo recursivo que define a série aplica-se, na prática, conforme a regra sugere: \n * começa-se a série com 0 e 1; a seguir, obtém-se o próximo número de Fibonacci somando-se \n * os dois anteriores e, assim, sucessiva e infinitamente.\n *\n * Esta implementação baseia-se na propriedade de dividir-para-conquistar aplicada à\n * potenciação de matrizes para acelerar o cálculo do número de fibonacci, reduzindo\n * a complexidade do algoritmo para O(lg n)\n * Complexidade:\n * O(lg n)\n * Dificuldade:\n * Médio\n * Referências:\n * http://assemblando.wordpress.com/2011/05/14/pela-uniao-dos-seus-poderes/\n *\n\"\"\"\n\nmatriz_semente = [[1,1],[1,0]]\n\ndef pow_matriz(b,n):\n \"\"\"Realiza a potenciação da matriz b pelo expoente n usando dividir-para-conquistar\"\"\"\n \n if n==1:\n return b\n\n if n%2:\n h = pow_matriz(b,(n-1)/2)\n return multi_matriz(multi_matriz(h,h),b)\n\n else:\n h = pow_matriz(b,n/2)\n return multi_matriz(h,h)\n\n\ndef multi_matriz(ma,mb):\n \"Realiza a multiplicação de duas matrizes 2x2\"\n\n (a,b),(c,d) = ma\n (e,f),(g,h) = mb\n return [[a*e+b*g,a*f+b*h],[c*e+d*g,c*f+d*h]]\n\n\ndef fibo(n):\n \"Realiza (matriz_semente)^n e retorna o elemento da linha zero, coluna um\"\n\n if n==0 or n==1:\n return n\n\n return pow_matriz(matriz_semente, n)[0][1]\n\n\nif __name__=='__main__':\n for i in range(100):\n print fibo(i)\n" }, { "path": "algorithms/math/number-theory/fibonacci.py", "content": "# -*- encoding: utf-8 -*-\n\"\"\"\n * Sequência de Fibonacci\n *\n * Autor:\n * Felipe Djinn \n * Colaborador:\n * Bruno Lara Tavares \n * Dilan Nery \n * Tipo:\n * math\n * Descrição:\n * Na matemática, os Números de Fibonacci são uma sequência definida como recursiva.\n * O algoritmo recursivo que define a série aplica-se, na prática, conforme a regra sugere: \n * começa-se a série com 0 e 1; a seguir, obtém-se o próximo número de Fibonacci somando-se \n * os dois anteriores e, assim, sucessiva e infinitamente.\n * Complexidade:\n * O(n)\n * Referências:\n * http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci\n *\n\"\"\"\ndef fibonacci(nesimo):\n c, n1, n2 = 0, 0, 1\n while c < nesimo:\n n1, n2 = n2, n1 + n2\n c += 1\n return n2\n\nfor nesimo in range(100):\n\tprint fibonacci(nesimo)\n" }, { "path": "algorithms/math/number-theory/miller-rabin.py", "content": "# -*- encoding: utf-8 -*-\n\"\"\"\nTeste de primalidade de Miller-Rabin\nAutor:\n Gary L Miller e Michael O. Rabin\nColaborador:\n Juan Lopes (me@juanlopes.net)\nTipo:\n math\nDescrição:\n Teste probabilistico de primalidade. Prova-se que para valores até \n 4.759.123.141, basta testar com as 'testemunhas' 2, 7 e 61. Este teste é \n muito mais rápido do que testar através de 'trial division', principalmente \n para números grandes.\nComplexidade: \n ?\nDificuldade:\n difícil\nReferências: (opcional)\n http://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test\n\"\"\"\n\ndef witness(a, n):\n u,t= (n/2, 1)\n while(u%2==0): \n u,t = (u/2, t+1)\n \n prev = pow(a,u,n);\n \n for i in xrange(t):\n curr=(prev*prev)%n\n if curr==1 and prev!=1 and prev!=n-1: return True\n prev=curr\n \n return curr != 1\n \ndef is_prime(n):\n if n in (0, 1): return False\n if n in (2, 7, 61): return True\n if witness(2,n): return False\n if witness(7,n): return False\n if witness(61,n): return False\n return True\n \nprint 'Primos ate 20:'\nfor i in xrange(1, 20):\n if is_prime(i):\n print i\n\nprint '2 147 483 647?', is_prime(2147483647)\nprint '2 147 483 648?', is_prime(2147483648)\n \n" }, { "path": "algorithms/math/number-theory/newton_raphson_sqrt.py", "content": "# -*- encoding: utf-8 -*-\n\"\"\"\nCálculo da raíz quadrada através do método de Newton-Raphson\nAutor:\n Isaac Newton e Joseph Raphson\nColaborador:\n Alysson Oliveira (lssn.oliveira@gmail.com)\nTipo:\n math\nDescrição:\n Método interativo para estimar as raízes de funções e pode ser aplicado\n a para o cálculo de rais quadrada.\nComplexidade:\n ?\nDificuldade:\n fácil\nReferências: (opcional)\n https://pt.wikipedia.org/wiki/M%C3%A9todo_de_Newton-Raphson\n https://courses.csail.mit.edu/6.006/fall11/rec/rec12_newton.pdf\n http://www.iaps.org.in/journal/index.php/journaliaps/article/view/161/146\n Guttag, John V. Introduction to Computation and Programming Using \\\n Python. MIT Press. 2013. ISBN 978-0-262-52500-8\n\"\"\"\n\n\ndef newton_raphson_sqrt(n, precisao=0.001, debug=False):\n \"\"\"\n n: Valor que se deseja obter a raíz\n precisao: Valor de precisão (ex.: 0.01)\n debug: Quando True mostra os chutes até que a precisão seja satisfeita\n \"\"\"\n chute = 0.5 * n\n while abs(chute * chute - n) >= precisao:\n if debug:\n print(' Chute:', chute)\n chute = chute - (((chute**2) - n) / (2 * chute))\n return chute\n\n\n# Testando a função\nfor i in 49, 64:\n print('Calculando raíz de {}'.format(i))\n print('Resultado: {}'.format(newton_raphson_sqrt(i)))\n print(35 * '=')\n\n\nfor i in 81, 100:\n print('Calculando raíz de {}'.format(i))\n print('Resultado: {}'.format(newton_raphson_sqrt(i, 0.01, True)))\n print(35 * '=')\n" }, { "path": "algorithms/math/number-theory/perfectnumber.py", "content": "# encoding: utf-8\n\"\"\" \nNúmeros perfeitos\nAutor: \n ?\nColaborador:\n Anna Cruz (anna.cruz@gmail.com)\nTipo:\n math, number-theory\nDescrição:\n 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\nComplexidade:\n ?\nDificuldade:\n fácil\nReferências:\n http://en.wikipedia.org/wiki/Perfect_numbers\n\"\"\"\n\ndef calc_perf(number):\n counter = 1\n divisors = []\n sumarize = 0\n while counter <= number/2:\n if number%counter == 0:\n divisors.append(counter)\n counter += 1\n for divisor in divisors:\n temp = divisor\n sumarize += divisor\n if sumarize == number:\n print \"This is a perfect number\"\n else:\n print \"This is not a perfect number try again\"\n\ncalc_perf(8128)\n" }, { "path": "algorithms/math/number-theory/pow.py", "content": "# coding: utf-8\n'''\nExponenciação\nAutor: \n \t?\nColaborador:\n \tDayvid Victor (victor.dvro@gmail.com)\nTipo:\n \tmath\nDescrição: \n\tcalcula exponenciação\nComplexidade de tempo: \n \tO(log n)\nDificuldade: \n \tfácil\nReferências:\n\t?\n'''\ndef pow(x, n):\n\tif n < 0:\n\t\treturn float(1) / float(pow(x, -n))\n\tp = (pow(x, n/2) if n != 0 else 1)\n\treturn (p * p if n % 2 == 0 else p * p * x)\n\nprint [pow(2,n) for n in range(11)]\nprint [pow(2,n) for n in range(-11,0)]\n\n\n\n" }, { "path": "algorithms/math/number-theory/powmod.py", "content": "# coding: utf-8\n'''\nExponenciação Modular\nAutor: \n ?\nColaborador:\n Juan Lopes \nTipo:\n math\nDescrição: \n Calcula exponenciação modular de inteiros em tempo logaritmico.\n \n Baseia-se no fato de que:\n (a*b)%n == ((a%n) * (b%n)) % n\nComplexidade de tempo: \n O(log n)\nDificuldade: \n fácil\nReferências:\n ?\n'''\ndef pow(x, e, m):\n if e==0: return 1\n p = pow(x,e/2,m)%m\n k = (1 if e%2==0 else x)\n return (p*p*k)%m\n\nfor i in range(20):\n print '3 ^ %d mod 1000 = %d (%d)' % (i, pow(3, i, 1000), 3**i)\n\n\n\n" }, { "path": "algorithms/math/number-theory/stirling.py", "content": "# -*- encoding: utf-8 -*-\n\"\"\"\n Fórmula de Stirling\n\n Autor:\n Pedro Menezes \n DiogoK \n Tipo:\n math\n Descrição:\n A Fórmula de Stirling estabelece uma aproximação assintótica para o fatorial de um número.\n Referências:\n http://pt.wikipedia.org/wiki/F%C3%B3rmula_de_Stirling\n\"\"\"\n\nfrom math import sqrt, pi, e, pow\n\ndef stirling(n):\n return sqrt(2*pi*n) * pow(n/e, n)\n\nif __name__ == '__main__':\n for n in xrange(1, 10):\n print(\"fat %d ~ %f\" %(n, stirling(n)))" }, { "path": "algorithms/misc/helloworld.py", "content": "\"\"\"\nHelloworld\nAutor:\n ?\nColaborador:\n Karlisson - contato@nerdson.com\nTipo:\n misc\nDescrição:\n Imprime a string Hello world\nComplexidade: \n O(1)\nDificuldade:\n facil\n\"\"\"\n\nprint \"Hello world\"\n" }, { "path": "algorithms/optimization/inteval_scheduling.py", "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo guloso de agendamento de intervalos\n\nAutor:\n\nColaborador:\n\tPedro Arthur Duarte (JEdi)\n\tpedroarthur.jedi@gmail.com\n\nTipo:\n\tInterval Scheduling\n\tGreed Algorithms\n\tOptimization\n\nDescrição:\n\tDado um conjunto de tarefas expressos como t = (s,e), onde 's' especifica\n\to inicio da tarefa e 'e' o seu fim, determinar o subconjunto máximo de\n\ttarefas que não se sobrepõem.\n\n\tUma das maneiras de determinar esse subconjunto consiste em selecionar\n\tgulosamente as tarefas com base no seu horário de término: as tarefas com\n\ttérmino mais cedo que não se sobrepõem são selecionadas para formar o\n\tsubconjunto de saída.\n\nComplexidade:\n\tO(n), para um conjunto de tarefas ordenadas;\n\n\tO(n) + O(g(n)), para um conjunto de tarefas não ordenadas, onde 'g' é\n uma função de ordenação.\n\nDificuldade:\n\tFácil\n\nReferências:\n\tKleinberg, Jon; Tardos, Eva (2006). Algorithm Design.\n\tISBN 0-321-29535-8\n\nLicença:\n\tGPLv3\n\n\"\"\"\n\ndef intervalScheduling(tasks):\n\t# Cópia a lista de tarefas e a ordena. O método \"sort\" das listas Python\n\t# é local. Portanto, caso seja necessário a lista original, não devemos\n\t# chamá-lo sem antes cloná-la.\n\ttasks = tasks[:]\n\ttasks.sort()\n\n\t# A tarefa com termino mais cedo sempre é a primeira do subconjunto\n\t# de saída\n\tscheduling = [ tasks[0] ]\n\n\t# Agora, para todos os outros elementos da lista ordenada de tarefas, nós\n\t# verificamos se esse elemento é compatível com as tarefas já presentes\n\t# no subconjunto de saída. Para uma lista ordenada, essa operação é O(1)\n\t# pois necessita apenas acessar a última tarefa inserida.\n\tfor t in tasks[1:]:\n\t\t# Se o momento de inicio da tarefa é maior ou igual ao fim da última\n\t\t# tarefa do subconjunto de saída, ela é compatível.\n\t\tif t.start >= scheduling[-1].end:\n\t\t\t# E, logo, nós a inserimos no subconjunto de saída\n\t\t\tscheduling.append(t)\n\n\t# Por último, retornamos a lista\n\treturn scheduling\n\n# Conjunto de tarefas de exemplo\n# --- ---- --------\n# ---- --- - --- ----\n# ---- -- -- --- --\n# ---- --- ---- ---\n\nclass Task:\n\t'''\n\tAbstração das tarefas\n\t'''\n\tstart = 0\n\tend = 0\n\n\tdef __init__(self, start, end):\n\t\tself.start = start\n\t\tself.end = end\n\n\tdef __repr__(self):\n\t\treturn '''''' % (self.start, self.end)\n\n\tdef __cmp__(self, o):\n\t\tif self.end < o.end:\n\t\t\treturn -1\n\n\t\tif self.end == o.end:\n\t\t\tif self.start < o.start:\n\t\t\t\treturn -1\n\t\t\telif self.start > o. start:\n\t\t\t\treturn 0\n\t\t\telse:\n\t\t\t\treturn 1\n\n\t\treturn 1\n\n# Em formato de lista\ntasks = [ Task(40, 70), Task(80, 120), Task(130, 210),\n Task(30, 70), Task(80, 110), Task(120, 130), Task(140, 170), Task(180, 220),\n Task(40, 80), Task(100, 120), Task(130, 150), Task(160, 190), Task(200, 220),\n Task(50, 90), Task(100, 130), Task(140, 180), Task(190, 220) ]\n\nprint intervalScheduling(tasks)\n" }, { "path": "algorithms/optimization/knapsack.py", "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo da Mochila\n\nAutor:\n\nColaborador:\n\tPedro Arthur Duarte (JEdi)\n\tpedroarthur.jedi@gmail.com\n\nTipo:\n\t0-1 Knapsack Problem\n\tUnbounded Knapsack\n\tDynamic Programming\n\nDescrição:\n \tDado uma conjunto de itens $I$ onde cada item $i$ possui um peso $p_i$ e um\n\tbenefício $b_i$ associado, e uma mochila de carga máxima $m$, maximizar o\n\tbenefício provido por uma combinação de itens respeitando a carga máxima\n\tsuportda pela mochila. Em outras, palavras,\n\tsatisfazer ao seguinte problema de otimização:\n\t%\n\t\\begin{itemize}\n\t\t\\item[] Maximizar $$\\sum_{i=1}^{n} b_i x_i$$\n\t\t\\item[] com a restrição $$\\sum_{i=1}^{n} p_i x_i \\le m$$\n\t\\end{itemize}\n\t%\n\tonde $x_i$ é no número de repetiçoes do item $i$. A versão mais simples do\n\tproblema, com cada item repetindo-se no máximo uma vez, ou $x_i \\le 1$, é\n\tconhecida como 0-1 Knapsack. Instâncias sem essa limitação são conhecidas\n\tcomo Unbounded Knapsack.\n\n % OBS: a descrição acima é melhor visualizada após processada pelo LaTeX.\n % Visite http://scribtex.com/ para um compilador on-line\n\nComplexidade:\n\tO(nm),\tpseudo-polinomial no tempo, onde 'n' é cardinalidade do conjunto de\n\t\t\titem e 'm' é a carga máxima da mochila.\n\n\tO(nm),\tpseudo-polinomial no espaço para o 0-1 Knapsack\n\t O(m),\tpseudo-polinomial no espaço para o Unbounded Knapsack\n\nDificuldade:\n\tMédia\n\nReferências:\n\tRobert Sdgewick. Algorithms in C. ISBN 0-201-51425-7\n\thttps://secure.wikimedia.org/wikipedia/en/wiki/Knapsack_problem\n\nLicença:\n\tGPLv3\n\n\"\"\"\n\nclass Item:\n\tdef __init__(self, value, weight, label=None):\n\t\tself.value = value\n\t\tself.weight = weight\n\n\t\tif label == None:\n\t\t\tself.label = str((self.value, self.weight))\n\t\telse:\n\t\t\tself.label = label\n\n\tdef __repr__(self):\n\t\treturn ''\n\nclass Knapsack:\n\tdef __init__(self, maxWeight, items=None):\n\t\tself.maxWeight = maxWeight\n\t\tself.items = items\n\n\tdef zeroOne(self, items=None):\n\t\t'''\n\t\tEssa instância do problema da mochila possuí subestrutura ótima. Logo,\n\t\té passível de resolução através de programação dinâmica. A seguinte\n\t\tformulação nos permite resolver esse problema numa abordagem bottom-up:\n\n\t\t% obs: LaTex code\n\t\t\\[\n\t\t\tM[i,j] = \\left\\{\n\t\t\t\t\\begin{array}{l l}\n\t\t\t\t\tM[i-1,j] & \\text{se } p_i < j \\\\\n\t\t\t\t\tmax(M[i-1,j], M[i,j-p_i] + b_i) & \\text{se } p_i \\ge j\\\\\n\t\t\t\t\\end{array}\n\t\t\t\\right.\n\t\t\\]\n\t\t%\n\t\tOnde $M$ é uma matriz $n \\times m$, $n$ é cardinalidade do conjunto\n\t\tde itens e $m$ a capacidade máxima da mochila.\n\t\t'''\n\t\tif not items:\n\t\t\titems = self.items\n\n\t\tM = [[ 0 ] * (self.maxWeight+1)]\n\n\t\tfor i,item in enumerate(items, start=1):\n\t\t\tM.append([ 0 ] * (self.maxWeight+1))\n\n\t\t\tfor w in xrange(1, self.maxWeight+1):\n\t\t\t\tif item.weight <= w:\n\t\t\t\t\tif M[i-1][w] > M[i-1][w-item.weight] + item.value:\n\t\t\t\t\t\tM[i][w] = M[i-1][w]\n\t\t\t\t\telse:\n\t\t\t\t\t\tM[i][w] = M[i-1][w-item.weight] + item.value\n\t\t\t\telse:\n\t\t\t\t\tM[i][w] = M[i-1][w]\n\n\t\t'''\n\t\t$M[n,m]$ nos informa o máximo benefício obtido. Porém, para recuperar\n\t\ta lista de itens escolhidos, Precisamos analisar a matriz $M$ mais a\n\t\tfundo.\n\n\t\tCaso o benefício da mochila com configuração $M[i,m]$ seja diferente do\n\t\tbenefício da mochila com configuração $M[i-1,m]$, o item $i$ está entre\n\t\tos itens escolhidos. Assim, devemos continuar nossa busca na posição\n\t\t$M[i-1,m-p_i]$. Caso contrário, o item $i$ não está em nossa mochila e\n\t\tdevemos continuar a busca na posição $M[i-1,m]$.\n\n\t\tO código abaixo o descrito acima.\n\t\t'''\n\t\ti,m = len(items), self.maxWeight\n\t\toutput = [ ]\n\n\t\twhile m > 0:\n\t\t\tif M[i][m] != M[i-1][m]:\n\t\t\t\toutput.append(items[i-1])\n\t\t\t\tm = m - items[i-1].weight\n\n\t\t\ti = i - 1\n\n\t\treturn M[-1][-1], output\n\n\tdef unbounded(self, items=None):\n\t\t'''\n\t\tEssa instância do problema também possuí subestrutura ótima. Logo,\n\t\ttambém é passível de resolução através de programação dinâmica. A\n\t\tseguinte formulação nos permite resolver esse problema numa abordagem\n\t\tbottom-up:\n\n\t\t% obs: LaTex code\n\t\t$$ \\displaystyle\n\t\tM[j] = max(M[j-1], ~\\max_{\\forall i \\in I | p_i < j}(b_i + M[j-p_i]))\n\t\t$$\n\t\t%\n\t\tOnde $M$ é uma arranjo de cardinalidade $m$ e $m$ é a capacidade\n\t\tmáxima da mochila.\n\t\t'''\n\t\tif not items:\n\t\t\titems = self.items\n\n\t\tM = [0] * (self.maxWeight+1)\n\t\t# Para que possamos recupera a lista de itens escolhidos, precisamos\n\t\t# de um arranjo auxiliar para armazenar a melhor escolha para a mochila\n\t\t# de tamanho 'j'.\n\t\tc = [None] * (self.maxWeight+1)\n\n\t\tfor i,item in enumerate(items, start=1):\n\t\t\tfor j in xrange(1, self.maxWeight+1):\n\t\t\t\tif item.weight <= j:\n\t\t\t\t\tif M[j] < M[j-item.weight] + item.value:\n\t\t\t\t\t\tM[j] = M[j-item.weight] + item.value\n\t\t\t\t\t\tc[j] = item\n\n\t\t'''\n\t\tConceitualmente, $c[m]$ sempre está na mochila. Agora, para recuperar o\n\t\trestante dos itens, pasta decrementar m pelo peso do do item na posição\n\t\tem questão ($m = m - p_{c[m]}$)\n\t\t'''\n\t\tm = self.maxWeight\n\t\toutput = [ ]\n\n\t\twhile m > 0:\n\t\t\toutput.append(c[m])\n\t\t\tm = m - c[m].weight\n\n\t\treturn M[-1], output\n\nitems = [\n\tItem(15,2), Item(5,1), Item(20,3), Item(60,2)\n]\n\nk = Knapsack(6, items)\n\nprint k.zeroOne()\nprint k.unbounded()" }, { "path": "algorithms/pattern-matching/AhoCorasick.py", "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo de Aho-Corasick.\n\nAutor:\n\tAlfred Aho and Margaret Corasick (1975)\n\nColaborador:\n\tPedro Arthur Duarte (JEdi)\n\tpedroarthur.jedi@gmail.com\n\nTipo:\n\tmulti pattern string matching\n\tfinite automate-based\n\nDescrição:\n\tDado um conjunto de padrões, esse algoritmo constrói uma máquina de estados\n\tfinitos de forma que seja possível buscá-los no texto de entrada em tempo\n\tlinearmente proporcional ao tamanho dessa última. Para isso, o algoritmo de\n\tAho-Corasick utiliza uma estrutura de dados semelhante as Tries, porém com\n\tnós adicionais que evitam a necessidade de backtracking. Esse nós\n\tadicionais representam o maior prefixo comum presente entre os padrões.\n\nComplexidade:\n\tO(⅀m) de pré-processamento, onde \"m\" é o tamanho do padrão\n\tO(n) de busca, onde \"n\" é o tamanho do texto de entrada\n\nDificuldade:\n média (?)\n\nReferências:\n https://en.wikipedia.org/wiki/Aho-Corasick_algorithm\n\nLicença:\n GPLv3\n\n\"\"\"\n\nclass AhoCoraski(dict):\n\tfailTransition = None\n\tisTerminal = False\n\n\tdef __init__(self, patternList=None, thenBuild=False):\n\t\tif patternList is not None:\n\t\t\tself.add(patternList)\n\n\t\tif thenBuild is True:\n\t\t\tself.build()\n\n\tdef add(self, pattern):\n\t\tif isinstance(pattern, list):\n\t\t\tfor w in pattern:\n\t\t\t\tself.add(w)\n\n\t\t\treturn self\n\n\t\tcurrentState = self\n\n\t\tfor c in pattern:\n\t\t\tif c not in currentState:\n\t\t\t\tcurrentState[c] = AhoCoraski()\n\n\t\t\tcurrentState = currentState[c]\n\n\t\tcurrentState.isTerminal = pattern\n\n\t\treturn self\n\n\tdef build(self):\n\t\tqueue = [ self ]\n\n\t\twhile len(queue) > 0:\n\t\t\tcurrent = queue.pop(0)\n\n\t\t\tfor transition, next in current.iteritems():\n\t\t\t\tstate = current.failTransition\n\n\t\t\t\twhile state is not None and transition not in state:\n\t\t\t\t\tstate = state.failTransition\n\n\t\t\t\tif state is not None:\n\t\t\t\t\tnext.failTransition = state[transition]\n\t\t\t\telse:\n\t\t\t\t\tnext.failTransition = self\n\n\t\t\t\tqueue.append(next)\n\n\t\treturn self\n\n\tdef match(self, subject):\n\t\toutput = [ ]\n\t\tcurrent = self\n\n\t\tif isinstance(subject, list):\n\t\t\tfor s in subject:\n\t\t\t\toutput += self.match(s)\n\n\t\t\treturn output\n\n\t\tfor c in subject:\n\t\t\tif c in current:\n\t\t\t\tcurrent = current[c]\n\t\t\telse:\n\t\t\t\tcurrent = current.failTransition\n\n\t\t\t\twhile current is not None and c not in current:\n\t\t\t\t\tcurrent = current.failTransition\n\n\t\t\t\tif current is not None:\n\t\t\t\t\tcurrent = current[c]\n\t\t\t\telse:\n\t\t\t\t\tcurrent = self\n\n\t\t\tif current.isTerminal is not False:\n\t\t\t\toutput.append(current.isTerminal)\n\n\t\treturn output\n\npatternList = [ 'he', 'she', 'his', 'her', 'show', 'shall', 'hall', ]\n\nprint AhoCoraski(patternList, True).match(\"This phrase shall match\")\n" }, { "path": "algorithms/pattern-matching/hamming.py", "content": "# coding: utf-8\n\"\"\"\nHamming Distance\nAutor:\n Richard Hamming\nColaborador:\n Guido Luz Percú (guidopercu@gmail.com)\nTipo:\n edit-distance\nDescrição:\n A distância de Hamming, é o número de posições em duas strings de mesmo\n tamanho onde os símbolos correspondentes são diferentes. Mede o mínimo\n número de substituições (ou o número de erros) necessárias para transformar\n uma string em outra.\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n https://pt.wikipedia.org/wiki/Dist%C3%A2ncia_de_Hamming\n http://www.caip.rutgers.edu/~bushnell/dsdwebsite/hamming.pdf\nLicenca:\n MIT\n\"\"\"\n\n\ndef hamming_distance(s1, s2):\n assert len(s1) == len(s2)\n return sum(ch1 != ch2 for ch1, ch2 in zip(s1, s2))\n\n\nprint(hamming_distance('ACGT', 'AGCT'))\n" }, { "path": "algorithms/pattern-matching/kmp.py", "content": "# -*- encoding: utf-8 -*-\n\"\"\"\nKMP (Knuth-Morris-Pratt) algorithm\nAutor:\n Donald Knuth, Vaughan Pratt and James H. Morris\nColaborador:\n Juan Lopes (me@juanlopes.net)\nTipo:\n pattern-matching\nDescrição:\n Encontra todas as instâncias de P em Q em tempo linear.\n Usa tabela de lookup inicializada por P.\nComplexidade: \n O(n+m)\nDificuldade:\n Médio\nReferências: (opcional)\n http://en.wikipedia.org/wiki/KMP_algorithm\n\"\"\"\n\ndef kmp_init(P):\n F = [0]*(len(P)+1)\n i, j= 1, 0;\n while i\nTipo:\n physics\nDescrição:\n Informa a distância horizontal quem um projétil atingiu baseado na força aplicada, força da gravidade e ângulo da força.\nComplexidade:\n 0(1)\nDificuldade:\n facil\nReferências:\n [1]http://www.algosobre.com.br/fisica/balistica-e-lancamento-de-projetil.html\n\"\"\"\n\nfrom math import pi, sin, cos, radians\n\ndef simula_tiro(angle, forca, gravidade, startY):\n \n angleR = radians(angle) # As funções sin e cos trabalham com radianos\n \n time = 0 # tempo inicial do tiro\n # Define os vetores de força vertical e horizontal\n VetorVertical = sin(angleR) * forca\n VetorHorizontal = cos(angleR) * forca\n # Pow!\n Y = startY\n X = 0\n while Y > 0: # Enquanto a bala não cair...\n X = VetorHorizontal * time # Distância atual em X (S = V * t)\n Y = startY + (VetorVertical * time) - (gravidade * (time**2)) # Distância atual em Y (S = S0 + V*t + (a * t^2)/2)\n time += 1\n \n return angle, X, Y\n\nforca = float(raw_input(\"Qual será a força? \"))\ngravidade = float(raw_input(\"Qual será a força da gravidade? \"))\nstartY = float(raw_input(\"Qual será a altura do canhão? \"))\ntry:\n angle = float(raw_input(\"Qual será o ângulo? (Opcional) \"))\n dados = simula_tiro(angle, forca, gravidade, startY)\n resultado = \"Ângulo = %i\\n X = %.5f\\n Y = %.5f\\n\\n\" % (dados[0], dados[1], dados[2])\n print resultado\nexcept: \n for angle in range(0,91): # Faz a simulação em todos os ângulos de 0 a 90\n dados = simula_tiro(angle, forca, gravidade, startY)\n resultado = \"\\nÂngulo = %i\\nX = %.5f\\nY = %.5f\\n\" % (dados[0], dados[1], dados[2])\n print resultado\n" }, { "path": "algorithms/search/binary-search.py", "content": "# coding: utf-8\n'''\nBusca Binária\n\nAutor: \n \tJon Bentley\nColaborador:\n \tDayvid Victor (victor.dvro@gmail.com)\nTipo:\n\tsearch\nDescrição: \n\tFaz uma busca em um vetor ordenado, usando o recurso\n\t'dividir para conquistar'. Ele compara o valor a ser\n\tbuscado com o centro do vetor, se for menor, o mesmo\n\tprocedimento é feito com o sub-vetor da esquerda, se\n\tfor maior, com o sub-vetor da direita.\t\nComplexidade de tempo: \n O(log n)\nDificuldade: \n fácil\nReferências:\n\thttp://pt.wikipedia.org/wiki/Pesquisa_binária\n'''\n\ndef binary_search(value, l):\n\tif len(l) == 0:\n\t\treturn None\n\tmid = len(l)/2\n\tif value < l[mid]:\n\t\treturn binary_search(value, l[:mid])\n\telif value > l[mid]:\n\t\ttmp = binary_search(value, l[(mid + 1):])\n\t\treturn (tmp is not None) and tmp + mid + 1 or None\n\t\n\treturn mid\n\nl = [0,1,2,3,4,7]\nprint binary_search(-1,l)\nprint binary_search(0,l)\nprint binary_search(1,l)\nprint binary_search(2,l)\nprint binary_search(3,l)\nprint binary_search(4,l)\nprint binary_search(5,l)\nprint binary_search(6,l)\nprint binary_search(7,l)\nprint binary_search(8,l)\nprint binary_search(9,l)\n\n\n\n\n\n\n\n" }, { "path": "algorithms/search/linear-search.py", "content": "# encoding: utf-8\n\n\n\"\"\"\n Linear Search\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \n José Alberto O. Morais Filho (j.moraisg12@gmail.com)\nTipo:\n search\nDescrição:\n Utiliza força bruta em um array para retornar a posição de um valor nesse array, ou retornar -1, se nada\n for encontrado.\nComplexidade:\n O(n)\nDificuldade:\n fácil\n\"\"\"\n\n# Entrada:\n# array = vetor onde o valor será pesquisado\n# search = valor procurado\n# Saída:\n# a posição da primeira ocorrência do valor, ou -1, caso o valor não for encontrado\n\ndef linear_search(array, search):\n for k,v in enumerate(array):\n if v == search:\n return k\n \n return -1\n\n# Exemplos\n\na = [1,5, 6, 3, 7,4]\n\nprint linear_search(a, 6)\nprint linear_search(a, 60)\n\n" }, { "path": "algorithms/sequence/token.py", "content": "#!/usr/bin/env python\n# -*- coding: UTF-8 -*-\n\n\"\"\"\nToken\n\nAutor:\n ?\nColaborador:\n Felipe Djinn \nTipo:\n sequence\nDescrição:\n Gera um token aleatório\nComplexidade:\n ?\nDificuldade:\n facil\n\"\"\"\n\nimport random\nimport string\n\ndef token(length = 10):\n return ''.join(random.choice(string.letters) for i in xrange(length)) \n\n\n\"\"\"\nExamples\n\"\"\"\n\nprint \"Token com 10 caracteres (padrão): \" + token()\nprint \"Token com 5 caracteres: \" +token(5)\nprint \"Token com 15 caracteres \" +token(15)\n" }, { "path": "algorithms/sorting/bozosort.py", "content": "# encoding: utf-8\n\n\"\"\"\nBozosort\nAutor:\n Bozo\nColaborador:\n Karlisson Bezerra\nTipo:\n sorting\nDescrição:\n Embaralha um vetor indefinidamente, até que os números estejam em ordem.\nComplexidade: \n O(infinito)\nDificuldade:\n facil\nReferências:\n http://nerdson.com/blog/libbozo-01/\n http://pt.wikipedia.org/wiki/Bogosort\n\"\"\"\n\nfrom random import shuffle\n\ndef is_sorted(seq):\n # We define an empty sequence to be sorted by default.\n if not seq:\n return True\n\n # Otherwise, the sequence is sorted if every element is less or equal\n # than the next one.\n last = seq[0]\n for element in seq:\n if last > element:\n return False\n last = element\n return True\n\ndef bozosort(seq):\n while not is_sorted(seq):\n shuffle(seq)\n return seq\n\nprint bozosort([2,4,9,1,0,-4,17,8,0,23,67,-1])\n" }, { "path": "algorithms/sorting/bubblesort.py", "content": "# encoding: utf-8\n\n\"\"\"\nBubblesort\nAutor:\n ?\nTipo:\n sorting\nDescrição:\n Varre o vetor comparando cada um dos pares de números\n possíveis e trocando suas posições no vetor se necessário\nComplexidade: \n Pior caso: O(n²)\n Melhor caso: O(n²)\nDificuldade:\n facil\nReferências:\n http://en.wikipedia.org/wiki/Bubble_sort\n\"\"\"\n\ndef bubble(lst):\n for i, val1 in enumerate(lst):\n for j, val2 in enumerate(lst):\n if lst[i] < lst[j]:\n lst[i], lst[j] = lst[j], lst[i]\n return lst\n\nprint bubble([6, -7, 1, 12, 9, 3, 5])\n" }, { "path": "algorithms/sorting/dropsort.py", "content": "#!/usr/bin/env python2\n# -*- coding: utf-8 -*- \n\"\"\"\nNome do algoritmo\nAutor:\n David Morgan-Mar. \nColaborador:\n Vinícius dos Santos Oliveira \nTipo:\n sorting\nDescrição:\n Dropsort é um algoritmo de ordernação lossy (causa perdas de informações)\n rápido, one-pass (lê a entrada exatamente uma vez, em ordem)\n\n O dropsort itera sobre os elementos da lista e, quando encontra um elemento\n menor que o anterior, descarta-o.\nComplexidade: \n O(n)\nDificuldade:\n facil\nReferências:\n http://www.dangermouse.net/esoteric/dropsort.html\n http://students.cs.ndsu.nodak.edu/~abrjacks/dropsort.php (otimizações)\nLicenca:\n MIT\n\"\"\"\n\ndef dropsort(lst):\n i = 0\n prev = None\n while i != len(lst):\n if prev > lst[i]:\n del lst[i]\n else:\n prev = lst[i]\n i += 1\n\n return lst\n\nif __name__ == '__main__':\n if dropsort([]) != []:\n exit(1)\n\n if dropsort([1, 2, 5, 3, 4, 6]) != [1, 2, 5, 6]:\n exit(1)\n\n if dropsort([1, 2, 2, 4]) != [1, 2, 2, 4]:\n exit(1)\n\n if dropsort([2, 11, 9, 8, 5, 4, 10, 3, 6, 0, 7, 13, 1, 12]) != [2, 11, 13]:\n exit(1)\n" }, { "path": "algorithms/sorting/insertionsort.py", "content": "#!/usr/bin/env python\n# encoding: utf-8\n\n'''\nInsertion Sort\nAutor: \n ?\nTipo:\n sorting\nDescrição:\n Percorre uma lista da esquerda para direita e vai deixando os elementos\n mais a esquerda ordenados à medida que avança pela lista.\nComplexidade:\n Pior caso: O(n²)\n Melhor caso: O(n)\nDificuldade:\n Facil\nReferencia:\n http://pt.wikipedia.org/wiki/Insertion_sort\n'''\n\ndef insertion_sort(L):\n for i in range(1, len(L)):\n elemento = L[i]\n j = i - 1\n\n while j >= 0 and L[j] > elemento:\n L[j+1] = L[j]\n j -= 1\n L[j+1] = elemento\n\n return L\n" }, { "path": "algorithms/sorting/masochisticsort.py", "content": "#!/usr/bin/env python\n# coding: utf-8\n\n\"\"\"\nMasochistic Sort\nAuthor:\n Dilan Nery \nColaborador:\n Dilan Nery \nTipo:\n Ordenação\nDescrição:\n Testa todas combinações possiveis de uma lista até encontrar a combinação\n em que a lista esteja ordenada\nComplexidade:\n ?\nDificuldade:\n medio\nLicensa:\n LGPL\n\"\"\"\n\ndef masoquist_sort(L):\n if len(L) == 1:\n yield L\n elif len(L) == 2:\n count = 0\n while count < 2:\n L[0],L[1] = L[1],L[0]\n yield L\n count += 1\n else:\n for i in range(len(L)):\n L_copy = L[:]\n key = L_copy.pop(i)\n invert = masoquist_sort(L_copy)\n\n for i in invert:\n yield [key] + i\n \ndef is_sorted(L):\n flag = True\n for i in range(1,len(L)):\n if L[i-1] > L[i]:\n flag = False\n return flag \n\nif __name__ == '__main__':\n teste1 = masoquist_sort([2,4,1,5,4])\n for t1 in teste1:\n if is_sorted(t1):\n print t1\n break\n\n teste2 = masoquist_sort([2, 11, 9, 8, 5, 4, 10, 3, 6, 0, 7, 13, 1, 12])\n for t2 in teste2:\n if is_sorted(t2):\n print t2\n break\n" }, { "path": "algorithms/sorting/mergesort.py", "content": "# coding: utf-8\n\n\"\"\"\nMergesort\nAutor:\n\tJohn von Neumann, em 1945\nColaborador:\n\tAdriano Melo (adriano@adrianomelo.com)\n\tDayvid Victor (victor.dvro@gmail.com)\nTipo:\n\tsorting\nDescrição:\n\tO algoritmo ordena um vetor dividindo-o pela metade e, depois de processar\n\tcada metade recursivamente, intercala as metades ordenadas.\nComplexidade:\n\tO (n*log(n))\nDificuldade:\n\tfácil\nReferências:\n\t?\n\"\"\"\n\ndef intercala (inicio, fim):\n\tresult = []\n\ti, j = 0, 0\n\n\twhile i < len(inicio) and j < len(fim):\n\t\tif inicio[i] < fim[j]:\n\t\t\tresult.append(inicio[i])\n\t\t\ti = i + 1\n\n\t\telif inicio[i] >= fim[j]:\n\t\t\tresult.append(fim[j])\n\t\t\tj = j + 1\n\n\tresult = result + inicio[i:]\n\tresult = result + fim [j:]\n\t\n\treturn result\n\ndef mergesort(array):\n\ttamanho = len(array)\n\n\tif tamanho == 1:\n\t\treturn array\n\n\tinicio = mergesort (array[0:tamanho/2])\n\tfim = mergesort (array[tamanho/2:])\n\n\treturn intercala (inicio, fim)\n\nprint mergesort ([2,8,-2,1,45,37,-463,24,50,80,4,3,7,4,55])\nprint mergesort ([8,7,3,4,5])\n\n\n" }, { "path": "algorithms/sorting/quicksort.py", "content": "# coding: utf-8\n\"\"\"\nQuicksort\nAutor:\n C.A.R. Hoare\nColaborador:\n Adriano Melo (adriano@adrianomelo.com)\n Juan Lopes (me@juanlopes.net)\nTipo:\n sorting\nDescrição:\n Quicksort é um algorítmo de ordenação de vetores cuja estratégia é\n dividir para conquistar. Basicamente o algorítmo organiza os elementos\n dos vetores de forma que os menores estejam antes dos maiores.\n Esse passo é feito recursivamente até que a lista completa esteja ordenada.\nComplexidade: \n O(n log(n)) - Melhor caso e médio caso.\n O(n²) - Pior caso.\nDificuldade:\n facil\nReferências: (opcional)\n http://pt.wikipedia.org/wiki/Quicksort\n\"\"\"\nfrom random import randint\n\ndef quicksort(V):\n if len(V) <= 1: \n return V\n \n pivot = V[0]\n equal = [x for x in V if x == pivot]\n lesser = [x for x in V if x < pivot]\n greater = [x for x in V if x > pivot]\n return quicksort(lesser) + equal + quicksort(greater)\n\nprint quicksort([i for i in xrange(30)]) # worst case\nprint quicksort([3 for i in xrange(30)]) # best case\nprint quicksort([randint(-100, 400) for i in xrange(30)]) # average case\n\n" }, { "path": "algorithms/sorting/selectionsort.py", "content": "# encoding: utf-8\n'''\nInsertion Sort\nAutor:\n ?\nColaborador:\n\tBruno Coimbra \nTipo:\n sorting\nDescrição:\n\tPercorre uma lista a procura do menor valor e inclui na posição correta.\nComplexidade:\n\tO(n²)\nDificuldade:\n Facil\nReferencia:\n http://pt.wikipedia.org/wiki/Selection_sort\n'''\nfrom random import randint\n\ndef selectionsort(L):\n\tfor i in range(0, len(L)):\n\t\tminor = L[i]\n\t\tminor_pos = i\n\t\tfor j in range(i+1, len(L)):\n\t\t\tif L[j] < minor:\n\t\t\t\tminor = L[j]\n\t\t\t\tminor_pos = j\n\t\tL[i], L[minor_pos] = minor, L[i]\n\treturn L\n\nA = [randint(1, 50) for i in range(30)]\nprint A\nprint selectionsort(A)\n\n" }, { "path": "algorithms/sorting/sleepsort.py", "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nSleepsort\nAutor:\n ?\nColaborador:\n Saulo Andrade Almeida \nTipo:\n sorting\nDescrição:\n Uma brincadeira sobre ordenacao numerica baseada em threads e sleep.\n O algoritimo dispara threads para cada numero que sera ordenado com o \n tempo de espera baseado no valor do numero, ou seja quanto maior o \n numero mais ele demora para acordar e ser reinserido na nova estrututa \n ordenada.\n\n Para utilizar o algoritimo basta executar o arquivo e uma lista padrao \n sera executado, ou informar um lista de valores separados por espacos.\n Ex: $ python sleepsort.py ou $ python sleepsort 4 7 3 9 8 1 2\nComplexidade: \n ?\nDificuldade:\n facil\nReferências: (opcional)\n Adaptado de http://dis.4chan.org/read/prog/1295544154\n\"\"\"\n\nimport sys, time, threading\n\ndef sleepit(val):\n time.sleep(val/4.0)\n print val\n\n# se nao vier parametro, usa uma lista padrao\nif not sys.argv[1:] :\n values = [7,9,2,5,6,4,1,8,3]\n\n# se vier, usa a lisra informada\nelse:\n values = sys.argv[1:]\n\n# loop que dispara as threads \nprint \"Ordenando a lista \", values\n[ threading.Thread(target=sleepit, args=[int(a)]).start() for a in values ]\n" }, { "path": "modelo.txt", "content": "\n\"\"\"\nNome do algoritmo\nAutor:\n Nome do autor do algoritmo ou ? caso nao saiba\nColaborador:\n Seu nome e email\nTipo:\n tipo do algoritmo (em ingles, minusculo, separado por hifen)\n Exemplos: math, number-theory, sorting\nDescrição:\n O que este algoritmo faz? Serve pra que? Tente explicar\n da melhor forma possivel, ja que este projeto tem como\n publico-alvo os iniciantes.\nComplexidade: \n O(n), O(n^2)... ou ?, caso nao saiba\nDificuldade:\n facil, medio ou dificil\nReferências: (opcional)\n links de referencia, um por linha\nLicenca:(opcional)\n GPL, BSD...\n\"\"\"\n\n#codigo\n" }, { "path": "other-languages/ai/genealogicaltree/genealogicaltree.pro", "content": "/*\nÁrvore Genealógica\nAutor:\n ???\nColaborador:\n Filipe Saraiva (filip.saraiva@gmail.com)\nTipo:\n ai\nDescrição:\n Implementação de uma árvore genealógica em\n Prolog. Teste do mecanismo de inferência da\n linguagem.\nComplexidade:\n ???\nDificuldade:\n médio\nReferências:\n [1] Palazzo, L. Introdução à Programação Prolog, Editora da\n\tUniversidade Católica de Pelotas, Pelotas, 1997.\n*/\n\n/*\n * Este código serve para apresentar os rudimentos da inferência\n * lógica da linguagem Prolog. Nele, criamos uma árvore genealógica\n * e, a partir da base de dados (\"fatos\"), conseguiremos extrair\n * conhecimento não disponível anteriormente.\n */\n\n/*\n * Fatos - Base de Dados\n */\npai(raimundo, ana).\npai(raimundo, renata).\npai(raimundo, lucio).\n\npai(estevao, marcelo).\npai(estevao, pamela).\n\npai(henrique, filomena).\n\nmae(marcela, ana).\nmae(marcela, renata).\n\nmae(sofia, lucio).\n\nmae(clarisse, marcelo).\nmae(clarisse, pamela).\n\nmae(sofia, filomena).\n\nmasculino(raimundo).\nmasculino(estevao).\nmasculino(henrique).\nmasculino(lucio).\nmasculino(marcelo).\n\nfeminina(marcela).\nfeminina(sofia).\nfeminina(clarisse).\nfeminina(ana).\nfeminina(renata).\nfeminina(pamela).\nfeminina(filomena).\n\n/*\n * Predicados\n */\n\n% Verifica quais pessoas tem o mesmo pai e a mesma mãe de uma\n% pessoa \"X\". Estas são \"irmãos total\".\nirmaostotal(X, Z) :- pai(Y, X), mae(K, X), pai(Y, Z), mae(K, Z).\n" }, { "path": "other-languages/ai/sokoban/alberta/screen.1", "content": "11 19\n###################\n#####...###########\n#####o..###########\n#####..o###########\n###..o.o.##########\n###.#.##.##########\n#...#.##.#####..xx#\n#.o..o..........xx#\n#####.###.#I##..xx#\n#####.....#########\n###################\n\n" }, { "path": "other-languages/ai/sokoban/alberta/screen.1.sol", "content": "" }, { "path": "other-languages/ai/sokoban/alberta/screen.31", "content": "16 18\n##################\n###..#############\n###..##..#...#####\n##..o#.oIo...#####\n##o..o..#.o.o#..##\n##..o##.#o.o.....#\n#..#..#.#...ooo..#\n#.o....o..o##.####\n#.o.o.#o#..#..####\n##..###..###o.####\n##..#xxxx.....####\n#####xxxxxx#######\n####xxxx##########\n####xxx###########\n####xxx###########\n##################\n\n\n" }, { "path": "other-languages/ai/sokoban/runtests.sh", "content": "echo \"As saídas do programa são jogadas nos arquivos .sol\"\ng++ -O2 -o sokoban sokoban.cpp\n\necho \"teste 1\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.sol\n\necho \"teste 2\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.sol\n\necho \"teste 3\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.sol\n\necho \"teste 4\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.sol\n\necho \"teste 5\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.sol\n\nreturn;\n\necho \"teste 6\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.sol\n\necho \"teste 7\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.sol\n\necho \"teste 8\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.sol\n\necho \"teste 9\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.out sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.sol\n\necho \"teste 10\"\n ./sokoban < sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.in > sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.out\ndiff sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.out sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.sol\n\n" }, { "path": "other-languages/ai/sokoban/sokoban.cpp", "content": "/*\n# -*- coding: utf-8 -*-\n\n\"\"\"\nAlgoritmo A* aplicado na resolução de um sokoban + representação de estados \npor meio de grafo de estados.\n\nAutores: \n Peter Hart, Nils Nilsson and Bertram Raphael \nColaborador:\n \tPéricles Lopes Machado [gogo40] (pericles.raskolnikoff.gmail.com)\nTipo: \n graphs\nDescrição: \n O Algoritmo A* é uma generalização do algoritmo de Dijkstra que\npermite acelerar a busca com uma heuristica que utiliza propriedades do grafo \npara estimar a distância para o destino. Este algoritmo é ideal quando aplicados\nem grades ou representações espaciais e em situações em que já conhecemos a\nposição do destino. \n\tO grafo de estados é uma representação importante que permite implementar\nmais facilmente AIs que buscam soluções ótimas pra puzzles.\n\tO sokoban é um problema NP difícil, então basicamente procura-se utilizar\nheurísticas que estimam a solução correta para acelarar as buscas. Este\nalgoritmo realiza algumas podas para evitar expandir muito o grafo de estados.\nObviamente, ele é muito simples ainda, já que há heurísticas bem mais sofisticadas\ndisponíveis na literatura[4].\n\nComplexidade: \n O(2^N)\nDificuldade: \n Difícil\nReferências:\n [1] http://en.wikipedia.org/wiki/A*_search_algorithm\n [2] http://falapericles.blogspot.com.br/2009/05/o-algoritmo.html\n\t[3] http://falapericles.blogspot.com.br/2009/05/grafo-de-estados-e-suas-aplicacoes.html\n\t[4] http://webdocs.cs.ualberta.ca/~games/Sokoban/\n\"\"\"\n*/\n\n\n/*\nPara testar esse programa, por favor utilize o script runtests.sh.\nComo ele é uma heurística, ainda é necessário melhorias para que ele\nconsiga resolver todos problemas disponíveis nesse branch.\n\nA repositório onde se encontra o desenvolvimento contínuo desse\nprograma se encontra aqui: git@github.com:gogo40/gogoSokoban.git\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n/*\nEstrutura de dados para representar um estado do problema\nAlfabeto do jogo:\n\t\t'.' espaco vazio\n\t\t'#' parede\n\t\t'I' personagem\n\t\t'J' personagem no destino\n\t\t'x' destino caixa\n\t\t'o' caixa\n\t\t'O' caixa no destino\n*/\nstatic int mask[600];\nstatic char rm[8];\n\nvoid initCState() {\n\tmask['.'] = 0; rm[0] = '.';\n\tmask['#'] = 1; rm[1] = '#';\n\tmask['I'] = 2; rm[2] = 'I';\n\tmask['J'] = 3; rm[3] = 'J';\n\tmask['x'] = 4; rm[4] = 'x';\n\tmask['o'] = 5; rm[5] = 'o';\n\tmask['O'] = 6; rm[6] = 'O';\n\n}\n\n/*\nNós representamos um estado por meio de palavra de (N*M)/10 bytes, onde\nN e M são as dimensões da grade do sokoban\n*/\nclass cState {\n\tpublic:\n\t\n\t\tcState(const cState& s) {\n\t\t\tN = s.N;\n\t\t\tM = s.M;\n\t\t\tv = s.v;\n\t\t}\n\t\t\n\t\tcState(int N = 0, int M = 0)\n\t\t: N(N), M(M), v( (N*M)/10 + 1, 0) {}\n\t\t\n\t\tchar get(int i, int j) {\n\t\t\tint k = i * M + j;\n\t\t\tint p = k / 10;\n\t\t\tint n = k % 10;\n\t\t\tint value = (v[p] >> (3 * n) ) & 7;\n\t\t\t\n\t\t\treturn rm[value];\n\t\t}\n\t\t\n\t\tvoid insert(int i, int j, char c) {\n\t\t\tint value = mask[c];\n\t\t\tint k = i * M + j;\n\t\t\tint p = k / 10;\n\t\t\tint n = k % 10;\n\t\t\tint w = v[p] & (7 << (3*n));\n\t\t\tv[p] ^= w;\n\t\t\tv[p] |= value << (3 * n); \n\t\t}\n\t\t\n\t\t\n\t\tcState& operator=(const cState& x) {\n\t\t\tN = x.N;\n\t\t\tM = x.M;\n\t\t\tv = x.v;\n\t\t\treturn *this;\n\t\t}\n\t\t\n\t\tvoid print() {\n\t\t\tfor (int i = 0; i < N; ++i) {\n\t\t\t\tfor (int j = 0; j < M; ++j) {\n\t\t\t\t\tprintf(\"%c\", get(i, j));\n\t\t\t\t}\n\t\t\t\tprintf(\"\\n\");\n\t\t\t}\n\t\t}\n\t\n\tfriend bool operator<(const cState& a, const cState& b);\n\tfriend bool operator==(const cState& a, const cState& b);\n\t\n\tbool operator()(const cState& b) {\n\t\tif (N > b.N or M > b.M) return false;\n\t\tif (*this == b) return false;\n\t\t\n\t\tfor (int i = 0; i < v.size(); ++i) \n\t\t\tif (v[i] > b.v[i]) {\n\t\t\t\tprintf(\"false...\\n\");\n\t\t\t\treturn false;\n\t\t\t}\n\t\tprintf(\"true...\\n\");\n\t\treturn true;\n\t}\n\t\n\tprivate:\n\t\n\t\t\n\t\tint N, M;\n\t\t\n\t\tvector v;\n};\n\n\n/* Verifica se dois estados são iguais*/\nbool operator==(const cState& a, const cState& b) {\n\n\tfor (int i = 0; i < a.v.size(); ++i) \n\t\tif (a.v[i] != b.v[i]) {\n\t\t\treturn false;\n\t\t}\n\n\treturn true;\n}\n\n/* realiza a comparação lexicográfica dos dois estados*/\nbool operator<(const cState& a, const cState& b) {\n\t\n\treturn lexicographical_compare(a.v.begin(), a.v.end(), b.v.begin(), b.v.end());\n}\n\n///////////////////////////////////////////////////////\n\nint N, M;\n\n/* Movimentações possíveis pelo jogador do sokoban*/\nint dx[] = {-1, 1, 0, 0};\nint dy[] = { 0, 0, -1, 1};\n\n\ntypedef pair State;\ntypedef pair pState;\n\nvector vs;\nvector > vbox;\nmap ids;\n\n/*Imprime um estado*/\nvoid print(cState& s) {\n\ts.print();\n\tcout << endl;\n}\n\n/*Transforma um estado numa string*/\nstring getStr(cState& s) {\n\tstring out = \"\";\n\tfor (int i = 0; i < N; ++i)\n\t\tfor (int j = 0; j < M; ++j)\n\t\t\tout += s.get(i, j);\n\treturn out;\n}\n\n/* Transforma uma string num grafo de estado*/\ncState getVec(string& s) {\n\tcState v(N, M);\n\n\tint n = 0;\n\n\tfor (int i = 0; i < N; ++i)\n\t\tfor (int j = 0; j < M; ++j){\n\t\t\tv.insert(i, j, s[n]);\n\t\t\t++n;\n\t\t}\n\n\treturn v;\n}\n\n/*Destinos das caixas*/\nvector pfx;\nvector pfy;\n\ninline int abs(int a) { return a>0?a:-a; }\n\n/*Calcula estimativa de jogadas que faltam pra concluir o sokoban*/\nint h(cState& s, int p, int id) {\n\tint d = 0;\n\tint x = p/M;\n\tint y = p%M;\n\tint nc = 0;\n\n\tfor (int n = 0; n < vbox[id].size(); ++n) {\n\t\t\tint i = vbox[id][n] / M;\n\t\t\tint j = vbox[id][n] % M;\n\t\t\tif (s.get(i, j) == 'o') {\n\t\t\t\tint dv = 2*(N + M);\n\t\t\t\tfor (int k = 0; k < pfx.size(); ++k) {\n\t\t\t\t\tint dx = abs(pfx[k] - i);\n\t\t\t\t\tint dy = abs(pfy[k] - j);\n\t\t\t\t\tint dp = (dx+dy);\n\t\t\t\t\tif (dp < dv) dv = dp;\n\t\t\t\t}\n\t\t\t\td += dv;\n\t\t\t\tnc++;\n\t\t\t}\n\t}\n\treturn d;\n}\n\n\n/*Verifica se chegamos num estado \"morto\"*/\nbool isDead(cState& s, int id) {\n\tbool ok = false;\n/*\n##\n#o (i-1, j+1)\n\n##\no# (i+1, j+1)\n\n\no#\n## (i+1, j-1)\n\n#o\n## (i-1, j-1)\n*/\n\tfor (int n = 0; n < vbox[id].size(); ++n) {\n\t\tint i = vbox[id][n] / M;\n\t\tint j = vbox[id][n] % M;\n\t\tif (s.get(i, j) == 'o') {\n\t\t\tif ((s.get(i-1, j) == '#' and s.get(i, j+1) == '#') or\n\t\t\t\t(s.get(i+1, j) == '#' and s.get(i, j+1) == '#') or\n\t\t\t\t(s.get(i+1, j) == '#' and s.get(i, j-1) == '#') or\n\t\t\t\t(s.get(i-1, j) == '#' and s.get(i, j-1) == '#')\n\t\t\t\t) {\n\t\t\t\t\tok = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t}\n\t}\n\treturn ok;\n}\n\n\n/*Realiza um movimento*/\nbool makeMove(cState& s, int x, int y, int k) {\n\n\tint px = x + dx[k];\n\tint py = y + dy[k];\n\n\tif (not (px > -1 and px < N and py > -1 and py < M)) {\n\t\treturn false;\n\t}\n\n\tswitch (s.get(px, py)) {\n\t\tcase '.': s.insert(px, py, 'o'); break;\n\t\tcase 'x': s.insert(px, py, 'O'); break;\n\t\tdefault: return false;\n\t}\n\n\treturn true;\n}\n\n/*Calcula a distância entre uma caixa e um posição final para a mesma.\nSimula o jogador realizando o movimento na caixa*/\nint calcDist(cState& s, int x, int y, int xf, int yf) {\n\tmap D;\n\tqueue Q;\n\tint ini, fim;\n\tini = fim = 0;\n\t\n\tQ.push(x * M + y);\n\t\n\tD[x * M + y] = 0;\n\n\twhile (not Q.empty()) {\n\t\tint u = Q.front();\n\t\t\n\t\tint du = D[u];\n\t\tint ux = u / M;\n\t\tint uy = u % M;\n\n\t\tif (ux == xf and uy == yf) break;\n\n\t\tQ.pop();\n\t\t\n\t\tfor (int k = 0; k < 4; ++k) {\n\t\t\tint vx = ux + dx[k];\n\t\t\tint vy = uy + dy[k];\n\t\t\tint v = vx * M +vy;\n\n\t\t\tif (vx > -1 and vx < N and vy > -1 and vy < M)\n\t\t\t\tif (s.get(vx, vy) == '.' || s.get(vx, vy) == 'x') {\n\t\t\t\t\tif (D.find(v) == D.end() || D[v] > du + 1) {\n\t\t\t\t\t\tD[v] = du + 1;\n\t\t\t\t\t\tQ.push(v);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t}\n\t}\n\n\treturn D.find(xf * M + yf) == D.end()? -1 : D[xf * M + yf];\n}\n\nState ini, fim;\nmap pi;\n\n/* Imprime a solução */\nvoid print_sol(State& u, int p, int du) {\n\tif (u == ini) return;\n\n\tprint_sol(pi[u], p + 1, du);\n\n\tif (u == fim) return;\n\n\tcState m = vs[u.first];\n\tint po = u.second;\n\tint x = po/M;\n\tint y = po%M;\n\n\tm.insert(x, y, 'I');\n\n\tcout<< du - p<< endl;\n\tprint(m);\n}\n\n/* Localiza a caixa na grade*/\nvoid findBox(vector& vb, cState& s) {\n\tfor (int i = 0; i < N; ++i)\n\t\tfor (int j = 0; j < M; ++j)\n\t\t\tif (s.get(i, j) == 'o' || s.get(i, j) == 'O') {\n\t\t\t\tvb.push_back(i * M + j);\n\t\t\t}\n}\n\nint main()\n{\n\tsrand(time(NULL));\n\tinitCState();\n\t\n\t/*Lê o estado inicial do jogo*/\n\tcin>>N>>M;\n\n\tcState s(N, M), f(N, M);\n\n\tfor (int i = 0; i < N; ++i) {\n\t\tstring a;\n\t\tcin>>a;\n\t\tfor (int j = 0; j < M; ++j) {\n\t\t\tf.insert(i, j, a[j]);\n\t\t\ts.insert(i, j, a[j]);\n\t\t}\n\t}\n\t\n\t/*\n\tAlfabeto do jogo:\n\t\t'.' espaco vazio\n\t\t'#' parede\n\t\t'I' personagem\n\t\t'J' personagem no destino\n\t\t'x' destino caixa\n\t\t'o' caixa\n\t\t'O' caixa no destino\n\t*/\n\n\tint xo, yo, po;\n\n\tpfx.clear();\n\tpfy.clear();\n\n\t/* Localiza elementos importantes da grade*/\n\tfor (int i = 0; i < N; ++i)\n\t\tfor (int j = 0; j < M; ++j)\n\t\t\tif (s.get(i, j) == 'I') {\n\t\t\t\tf.insert(i, j, '.');\n\t\t\t\ts.insert(i, j, '.');\n\t\t\t\t\n\t\t\t\tpo = i * M +j;\n\t\t\t\txo = i;\n\t\t\t\tyo = j;\n\t\t\t}else if (s.get(i, j) == 'J') {\n\t\t\t\ts.insert(i, j, 'x');\n\t\t\t\tf.insert(i, j, 'O');\n\t\t\t\t\n\t\t\t\tpo = i * M +j;\n\t\t\t\txo = i;\n\t\t\t\tyo = j;\n\t\t\t} else if (s.get(i, j) == 'x') {\n\t\t\t\tf.insert(i, j, 'O');\n\t\t\t\t\n\t\t\t\tpfx.push_back(i);\n\t\t\t\tpfy.push_back(j);\n\t\t\t} else if (s.get(i, j) == 'o') {\n\t\t\t\tf.insert(i, j, '.');\n\t\t\t\t\n\t\t\t} else {\n\t\t\t\tf.insert(i, j, s.get(i,j));\n\t\t\t}\n\n\t/*Localiza caixas*/\n\tvs.push_back(s);\n\tvbox.push_back(vector());\n\tfindBox(vbox[0], s);\n\tids[s] = 0;\n\n\tvs.push_back(f);\n\tvbox.push_back(vector());\n\tfindBox(vbox[1], f);\n\tids[f] = 1;\n\n\t\n\tini.first = 0;\n\tini.second = po;\n\n\tfim.first = 1;\n\tfim.second = -1;\n\n\tpi.clear();\n\n\tmap D;\n\n\tD[ini] = 0;\n\n\tbool ok = false;\n\tint ck = 1;\n\tint dmin = 1<<20;\n\n\t/* Tenta-se estimar quantas jogadas são necessárias para se concluir o jogo\n\t\tcaso a profundidade da busca ultrapasse L, então a busca é encerrada.\n\t\tO L é o \"branch factor\" do algoritmo.*/\n\tfor (int L = 250; L < 1000; L *= 2) {\n\n\t\tif (ok) break;\n\n\t\tpriority_queue Q;\n\t\tD.clear();\n\t\tQ.push(pState(0, ini));\n\t\tD[ini] = 0;\n\n\t\twhile (!Q.empty()) {\n\t\t\tint uest = -Q.top().first;\n\t\t\tState u = Q.top().second;\n\t\t\tint du = D[u];\n\t\t\t\n\t\t\tif (u == fim){\n\t\t\t\tok = true;\n\t\t\t\tdmin = du;\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tint p = u.second;\n\t\t\tint x = p / M;\n\t\t\tint y = p % M;\n\t\t\t\n\t\t\tQ.pop();\n\n\t\t\tif ( uest > L or uest >= dmin) continue;\n\t\t\telse if (u == fim){\n\t\t\t\tdmin = du;\n\t\t\t}\n\t\t\t\n\t\t\tif (ck % 50000 == 0) {\n\t\t\t\tcerr << du << \" dmin= \" << dmin << endl;\n\t\t\t}\n\t\t\t++ck;\n\t\t\t\n\t\t\t/*\n\t\t\tPara cada estado u, realiza-se uma busca nos 4 estados adjascentes.\n\t\t\t*/\n\t\t\tfor (int nb = 0; nb < vbox[u.first].size(); ++nb){\n\t\t\t\t\tint i = vbox[u.first][nb] / M;\n\t\t\t\t\tint j = vbox[u.first][nb] % M;\n\t\t\t\t\tif (vs[u.first].get(i, j) == 'o' || vs[u.first].get(i, j) == 'O') {\n\t\t\t\t\t\tint q = i * M + j;\n\n\t\t\t\t\t\tfor (int k = 0; k < 4; ++k) {\n\n\t\t\t\t\t\t\tcState m = vs[u.first];\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\tif (makeMove(m, i, j, k)) {\n\t\t\t\t\t\t\t\tm.insert(i, j, (vs[u.first].get(i, j) =='o')?'.':'x');\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\tint xf = i - dx[k];\n\t\t\t\t\t\t\t\tint yf = j - dy[k];\n\n\t\t\t\t\t\t\t\tint dup = calcDist(vs[u.first], x, y, xf, yf);\n\t\t\t\t\t\t\t\tif (dup > -1) {\n\t\t\t\t\t\t\t\t\tState v;\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\tif (ids.find(m) == ids.end()) {\n\t\t\t\t\t\t\t\t\t\tv.first = ids[m] = vs.size();\n\t\t\t\t\t\t\t\t\t\tvbox.push_back(vector());\n\t\t\t\t\t\t\t\t\t\tfindBox(vbox[vs.size()], m);\n\t\t\t\t\t\t\t\t\t\tvs.push_back(m);\n\t\t\t\t\t\t\t\t\t} else v.first = ids[m];\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\tif (isDead(m, v.first)) continue;\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\tif (v.first == fim.first) q = -1;\n\n\t\t\t\t\t\t\t\t\tv.second = q;\n\n\t\t\t\t\t\t\t\t\tif (D.find(v) == D.end()) {\n\t\t\t\t\t\t\t\t\t\tD[v] = du + dup + 1;\n\t\t\t\t\t\t\t\t\t\tpi[v]= u;\n\t\t\t\t\t\t\t\t\t\tint est = du + dup + 1 + h(m, p, v.first);\n\t\t\t\t\t\t\t\t\t\tif (est < dmin and est < L) Q.push(pState(-est, v));\n\t\t\t\t\t\t\t\t\t} else if (D[v] > du + dup + 1) {\n\t\t\t\t\t\t\t\t\t\tD[v] = du + dup + 1;\n\t\t\t\t\t\t\t\t\t\tpi[v] = u;\n\t\t\t\t\t\t\t\t\t\tint est = du + dup + 1 + h(m, p, v.first);\n\t\t\t\t\t\t\t\t\t\tif (est < dmin and est < L) Q.push(pState(-est, v));\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif (ok) {\n\t\tprint_sol(fim, 0, D[fim]);\n\t} else {\n\t\tcout << \"[Nao ha solucao... =(]\\n\";\n\t}\n\n\treturn 0;\n}\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.in", "content": "9 9\r\n#########\r\n#I..#####\r\n#.oo#####\r\n#.o.###x#\r\n###.###x#\r\n###....x#\r\n##...#..#\r\n##...####\r\n#########\r\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.out", "content": "59\n#########\n#...#####\n#.oI#####\n#.oo###x#\n###.###x#\n###....x#\n##...#..#\n##...####\n#########\n\n60\n#########\n#...#####\n#.o.#####\n#.oI###x#\n###o###x#\n###....x#\n##...#..#\n##...####\n#########\n\n61\n#########\n#...#####\n#.o.#####\n#.o.###x#\n###I###x#\n###o...x#\n##...#..#\n##...####\n#########\n\n62\n#########\n#...#####\n#.o.#####\n#.o.###x#\n###.###x#\n###I...x#\n##.o.#..#\n##...####\n#########\n\n63\n#########\n#...#####\n#.o.#####\n#.o.###x#\n###.###x#\n###....x#\n##.Io#..#\n##...####\n#########\n\n64\n#########\n#...#####\n#.o.#####\n#.o.###x#\n###.###x#\n###.o..x#\n##..I#..#\n##...####\n#########\n\n65\n#########\n#...#####\n#.Io#####\n#.o.###x#\n###.###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n66\n#########\n#...#####\n#..I#####\n#.oo###x#\n###.###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n67\n#########\n#...#####\n#...#####\n#.oI###x#\n###o###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n68\n#########\n#...#####\n#...#####\n#.o.###x#\n###I###x#\n###oo..x#\n##...#..#\n##...####\n#########\n\n69\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###x#\n###Io..x#\n##.o.#..#\n##...####\n#########\n\n70\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###x#\n###.Io.x#\n##.o.#..#\n##...####\n#########\n\n71\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###x#\n###..Iox#\n##.o.#..#\n##...####\n#########\n\n72\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###x#\n###...IO#\n##.o.#..#\n##...####\n#########\n\n73\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###O#\n###....I#\n##.o.#..#\n##...####\n#########\n\n74\n#########\n#...#####\n#...#####\n#.o.###O#\n###.###I#\n###....x#\n##.o.#..#\n##...####\n#########\n\n75\n#########\n#...#####\n#...#####\n#.o.###O#\n###.###x#\n###....x#\n##.Io#..#\n##...####\n#########\n\n76\n#########\n#...#####\n#...#####\n#.o.###O#\n###.###x#\n###.o..x#\n##..I#..#\n##...####\n#########\n\n77\n#########\n#...#####\n#...#####\n#.Io###O#\n###.###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n78\n#########\n#...#####\n#...#####\n#..I###O#\n###o###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n79\n#########\n#...#####\n#...#####\n#...###O#\n###I###x#\n###oo..x#\n##...#..#\n##...####\n#########\n\n80\n#########\n#...#####\n#...#####\n#...###O#\n###.###x#\n###Io..x#\n##.o.#..#\n##...####\n#########\n\n81\n#########\n#...#####\n#...#####\n#...###O#\n###.###x#\n###.Io.x#\n##.o.#..#\n##...####\n#########\n\n82\n#########\n#...#####\n#...#####\n#...###O#\n###.###x#\n###..Iox#\n##.o.#..#\n##...####\n#########\n\n83\n#########\n#...#####\n#...#####\n#...###O#\n###.###x#\n###...IO#\n##.o.#..#\n##...####\n#########\n\n84\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###....I#\n##.o.#..#\n##...####\n#########\n\n85\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###....x#\n##.Io#..#\n##...####\n#########\n\n86\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###.o..x#\n##..I#..#\n##...####\n#########\n\n87\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###.Io.x#\n##...#..#\n##...####\n#########\n\n88\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###..Iox#\n##...#..#\n##...####\n#########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-01.sol", "content": "59\n#########\n#...#####\n#.oI#####\n#.oo###x#\n###.###x#\n###....x#\n##...#..#\n##...####\n#########\n\n60\n#########\n#...#####\n#.o.#####\n#.oI###x#\n###o###x#\n###....x#\n##...#..#\n##...####\n#########\n\n61\n#########\n#...#####\n#.o.#####\n#.o.###x#\n###I###x#\n###o...x#\n##...#..#\n##...####\n#########\n\n62\n#########\n#...#####\n#.o.#####\n#.o.###x#\n###.###x#\n###I...x#\n##.o.#..#\n##...####\n#########\n\n63\n#########\n#...#####\n#.o.#####\n#.o.###x#\n###.###x#\n###....x#\n##.Io#..#\n##...####\n#########\n\n64\n#########\n#...#####\n#.o.#####\n#.o.###x#\n###.###x#\n###.o..x#\n##..I#..#\n##...####\n#########\n\n65\n#########\n#...#####\n#.Io#####\n#.o.###x#\n###.###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n66\n#########\n#...#####\n#..I#####\n#.oo###x#\n###.###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n67\n#########\n#...#####\n#...#####\n#.oI###x#\n###o###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n68\n#########\n#...#####\n#...#####\n#.o.###x#\n###I###x#\n###oo..x#\n##...#..#\n##...####\n#########\n\n69\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###x#\n###Io..x#\n##.o.#..#\n##...####\n#########\n\n70\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###x#\n###.Io.x#\n##.o.#..#\n##...####\n#########\n\n71\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###x#\n###..Iox#\n##.o.#..#\n##...####\n#########\n\n72\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###x#\n###...IO#\n##.o.#..#\n##...####\n#########\n\n73\n#########\n#...#####\n#...#####\n#.o.###x#\n###.###O#\n###....I#\n##.o.#..#\n##...####\n#########\n\n74\n#########\n#...#####\n#...#####\n#.o.###O#\n###.###I#\n###....x#\n##.o.#..#\n##...####\n#########\n\n75\n#########\n#...#####\n#...#####\n#.o.###O#\n###.###x#\n###....x#\n##.Io#..#\n##...####\n#########\n\n76\n#########\n#...#####\n#...#####\n#.o.###O#\n###.###x#\n###.o..x#\n##..I#..#\n##...####\n#########\n\n77\n#########\n#...#####\n#...#####\n#.Io###O#\n###.###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n78\n#########\n#...#####\n#...#####\n#..I###O#\n###o###x#\n###.o..x#\n##...#..#\n##...####\n#########\n\n79\n#########\n#...#####\n#...#####\n#...###O#\n###I###x#\n###oo..x#\n##...#..#\n##...####\n#########\n\n80\n#########\n#...#####\n#...#####\n#...###O#\n###.###x#\n###Io..x#\n##.o.#..#\n##...####\n#########\n\n81\n#########\n#...#####\n#...#####\n#...###O#\n###.###x#\n###.Io.x#\n##.o.#..#\n##...####\n#########\n\n82\n#########\n#...#####\n#...#####\n#...###O#\n###.###x#\n###..Iox#\n##.o.#..#\n##...####\n#########\n\n83\n#########\n#...#####\n#...#####\n#...###O#\n###.###x#\n###...IO#\n##.o.#..#\n##...####\n#########\n\n84\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###....I#\n##.o.#..#\n##...####\n#########\n\n85\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###....x#\n##.Io#..#\n##...####\n#########\n\n86\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###.o..x#\n##..I#..#\n##...####\n#########\n\n87\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###.Io.x#\n##...#..#\n##...####\n#########\n\n88\n#########\n#...#####\n#...#####\n#...###O#\n###.###O#\n###..Iox#\n##...#..#\n##...####\n#########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.in", "content": "9 10\r\n##########\r\n#xx......#\r\n#xxo..#..#\r\n#..#o##.##\r\n#.o.....##\r\n#####.#.##\r\n###.o.I.##\r\n###.....##\r\n##########\r\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.out", "content": "28\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.Io..##\n###.....##\n##########\n\n29\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###..Io.##\n###.....##\n##########\n\n30\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###...Io##\n###.....##\n##########\n\n31\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#o##\n###....I##\n###.....##\n##########\n\n32\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o....o##\n#####.#I##\n###.....##\n###.....##\n##########\n\n33\n##########\n#xx......#\n#xxo..#..#\n#..#o##o##\n#.o....I##\n#####.#.##\n###.....##\n###.....##\n##########\n\n34\n##########\n#xx......#\n#xxo..#o.#\n#..#o##I##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n35\n##########\n#xx....o.#\n#xxo..#I.#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n36\n##########\n#xx...oI.#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n37\n##########\n#xx..oI..#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n38\n##########\n#xx.oI...#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n39\n##########\n#xxoI....#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n40\n##########\n#xOI.....#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n41\n##########\n#OI......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n42\n##########\n#Ox......#\n#xOI..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n43\n##########\n#Ox......#\n#OI...#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n44\n##########\n#Ox......#\n#Ox...#..#\n#..#o##.##\n#.Io....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n45\n##########\n#Ox......#\n#Ox...#..#\n#..#o##.##\n#..Io...##\n#####.#.##\n###.....##\n###.....##\n##########\n\n46\n##########\n#Ox......#\n#Ox...#..#\n#..#o##.##\n#...Io..##\n#####.#.##\n###.....##\n###.....##\n##########\n\n47\n##########\n#Ox......#\n#Ox.o.#..#\n#..#I##.##\n#....o..##\n#####.#.##\n###.....##\n###.....##\n##########\n\n48\n##########\n#Ox......#\n#Ox.o.#..#\n#..#.##.##\n#....Io.##\n#####.#.##\n###.....##\n###.....##\n##########\n\n49\n##########\n#Ox......#\n#Ox.o.#..#\n#..#.##.##\n#.....Io##\n#####.#.##\n###.....##\n###.....##\n##########\n\n50\n##########\n#Ox......#\n#Ox.o.#..#\n#..#.##o##\n#......I##\n#####.#.##\n###.....##\n###.....##\n##########\n\n51\n##########\n#Ox......#\n#Ox.o.#o.#\n#..#.##I##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n52\n##########\n#Ox....o.#\n#Ox.o.#I.#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n53\n##########\n#Ox...oI.#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n54\n##########\n#Ox..oI..#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n55\n##########\n#Ox.oI...#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n56\n##########\n#OxoI....#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n57\n##########\n#OOI.....#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n58\n##########\n#OO......#\n#OxoI.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-02.sol", "content": "28\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.Io..##\n###.....##\n##########\n\n29\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###..Io.##\n###.....##\n##########\n\n30\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###...Io##\n###.....##\n##########\n\n31\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#o##\n###....I##\n###.....##\n##########\n\n32\n##########\n#xx......#\n#xxo..#..#\n#..#o##.##\n#.o....o##\n#####.#I##\n###.....##\n###.....##\n##########\n\n33\n##########\n#xx......#\n#xxo..#..#\n#..#o##o##\n#.o....I##\n#####.#.##\n###.....##\n###.....##\n##########\n\n34\n##########\n#xx......#\n#xxo..#o.#\n#..#o##I##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n35\n##########\n#xx....o.#\n#xxo..#I.#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n36\n##########\n#xx...oI.#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n37\n##########\n#xx..oI..#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n38\n##########\n#xx.oI...#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n39\n##########\n#xxoI....#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n40\n##########\n#xOI.....#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n41\n##########\n#OI......#\n#xxo..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n42\n##########\n#Ox......#\n#xOI..#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n43\n##########\n#Ox......#\n#OI...#..#\n#..#o##.##\n#.o.....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n44\n##########\n#Ox......#\n#Ox...#..#\n#..#o##.##\n#.Io....##\n#####.#.##\n###.....##\n###.....##\n##########\n\n45\n##########\n#Ox......#\n#Ox...#..#\n#..#o##.##\n#..Io...##\n#####.#.##\n###.....##\n###.....##\n##########\n\n46\n##########\n#Ox......#\n#Ox...#..#\n#..#o##.##\n#...Io..##\n#####.#.##\n###.....##\n###.....##\n##########\n\n47\n##########\n#Ox......#\n#Ox.o.#..#\n#..#I##.##\n#....o..##\n#####.#.##\n###.....##\n###.....##\n##########\n\n48\n##########\n#Ox......#\n#Ox.o.#..#\n#..#.##.##\n#....Io.##\n#####.#.##\n###.....##\n###.....##\n##########\n\n49\n##########\n#Ox......#\n#Ox.o.#..#\n#..#.##.##\n#.....Io##\n#####.#.##\n###.....##\n###.....##\n##########\n\n50\n##########\n#Ox......#\n#Ox.o.#..#\n#..#.##o##\n#......I##\n#####.#.##\n###.....##\n###.....##\n##########\n\n51\n##########\n#Ox......#\n#Ox.o.#o.#\n#..#.##I##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n52\n##########\n#Ox....o.#\n#Ox.o.#I.#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n53\n##########\n#Ox...oI.#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n54\n##########\n#Ox..oI..#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n55\n##########\n#Ox.oI...#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n56\n##########\n#OxoI....#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n57\n##########\n#OOI.....#\n#Ox.o.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n58\n##########\n#OO......#\n#OxoI.#..#\n#..#.##.##\n#.......##\n#####.#.##\n###.....##\n###.....##\n##########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.in", "content": "8 6\r\n######\r\n##..##\r\n#Io.##\r\n##o.##\r\n##.o.#\r\n#xo..#\r\n#xxOx#\r\n######\r\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.out", "content": "20\n######\n##..##\n#.Io##\n##o.##\n##.o.#\n#xo..#\n#xxOx#\n######\n\n21\n######\n##..##\n#..o##\n##I.##\n##oo.#\n#xo..#\n#xxOx#\n######\n\n22\n######\n##..##\n#..o##\n##..##\n##oI.#\n#xoo.#\n#xxOx#\n######\n\n23\n######\n##..##\n#..o##\n##..##\n##o..#\n#xoo.#\n#xOIx#\n######\n\n24\n######\n##..##\n#..o##\n##..##\n##o..#\n#xoo.#\n#OIxx#\n######\n\n25\n######\n##..##\n#..o##\n##..##\n##o..#\n#xoI.#\n#OxOx#\n######\n\n26\n######\n##..##\n#..o##\n##..##\n##o..#\n#OI..#\n#OxOx#\n######\n\n27\n######\n##..##\n#..o##\n##..##\n##o..#\n#O...#\n#OxIO#\n######\n\n28\n######\n##..##\n#..o##\n##..##\n##I..#\n#Oo..#\n#OxxO#\n######\n\n29\n######\n##..##\n#..o##\n##..##\n##...#\n#OI..#\n#OOxO#\n######\n\n30\n######\n##..##\n#..I##\n##.o##\n##...#\n#O...#\n#OOxO#\n######\n\n31\n######\n##..##\n#...##\n##.I##\n##.o.#\n#O...#\n#OOxO#\n######\n\n32\n######\n##..##\n#...##\n##..##\n##.I.#\n#O.o.#\n#OOxO#\n######\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-03.sol", "content": "20\n######\n##..##\n#.Io##\n##o.##\n##.o.#\n#xo..#\n#xxOx#\n######\n\n21\n######\n##..##\n#..o##\n##I.##\n##oo.#\n#xo..#\n#xxOx#\n######\n\n22\n######\n##..##\n#..o##\n##..##\n##oI.#\n#xoo.#\n#xxOx#\n######\n\n23\n######\n##..##\n#..o##\n##..##\n##o..#\n#xoo.#\n#xOIx#\n######\n\n24\n######\n##..##\n#..o##\n##..##\n##o..#\n#xoo.#\n#OIxx#\n######\n\n25\n######\n##..##\n#..o##\n##..##\n##o..#\n#xoI.#\n#OxOx#\n######\n\n26\n######\n##..##\n#..o##\n##..##\n##o..#\n#OI..#\n#OxOx#\n######\n\n27\n######\n##..##\n#..o##\n##..##\n##o..#\n#O...#\n#OxIO#\n######\n\n28\n######\n##..##\n#..o##\n##..##\n##I..#\n#Oo..#\n#OxxO#\n######\n\n29\n######\n##..##\n#..o##\n##..##\n##...#\n#OI..#\n#OOxO#\n######\n\n30\n######\n##..##\n#..I##\n##.o##\n##...#\n#O...#\n#OOxO#\n######\n\n31\n######\n##..##\n#...##\n##.I##\n##.o.#\n#O...#\n#OOxO#\n######\n\n32\n######\n##..##\n#...##\n##..##\n##.I.#\n#O.o.#\n#OOxO#\n######\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.in", "content": "8 8\r\n########\r\n##I.####\r\n##.o..##\r\n###.#.##\r\n#x#.#..#\r\n#xo..#.#\r\n#x...o.#\r\n########\r\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.out", "content": "40\n########\n##..####\n##.I..##\n###o#.##\n#x#.#..#\n#xo..#.#\n#x...o.#\n########\n\n41\n########\n##..####\n##....##\n###o#.##\n#x#.#..#\n#xo..#.#\n#x..oI.#\n########\n\n42\n########\n##..####\n##....##\n###o#.##\n#x#.#..#\n#xo..#.#\n#x.oI..#\n########\n\n43\n########\n##..####\n##....##\n###o#.##\n#x#.#..#\n#OI..#.#\n#x.o...#\n########\n\n44\n########\n##..####\n##....##\n###o#.##\n#O#.#..#\n#I...#.#\n#x.o...#\n########\n\n45\n########\n##..####\n##....##\n###o#.##\n#O#.#..#\n#x...#.#\n#xoI...#\n########\n\n46\n########\n##..####\n##....##\n###o#.##\n#O#.#..#\n#x...#.#\n#OI....#\n########\n\n47\n########\n##..####\n##....##\n###I#.##\n#O#o#..#\n#x...#.#\n#O.....#\n########\n\n48\n########\n##..####\n##....##\n###.#.##\n#O#I#..#\n#x.o.#.#\n#O.....#\n########\n\n49\n########\n##..####\n##....##\n###.#.##\n#O#.#..#\n#xoI.#.#\n#O.....#\n########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-04.sol", "content": "40\n########\n##..####\n##.I..##\n###o#.##\n#x#.#..#\n#xo..#.#\n#x...o.#\n########\n\n41\n########\n##..####\n##....##\n###o#.##\n#x#.#..#\n#xo..#.#\n#x..oI.#\n########\n\n42\n########\n##..####\n##....##\n###o#.##\n#x#.#..#\n#xo..#.#\n#x.oI..#\n########\n\n43\n########\n##..####\n##....##\n###o#.##\n#x#.#..#\n#OI..#.#\n#x.o...#\n########\n\n44\n########\n##..####\n##....##\n###o#.##\n#O#.#..#\n#I...#.#\n#x.o...#\n########\n\n45\n########\n##..####\n##....##\n###o#.##\n#O#.#..#\n#x...#.#\n#xoI...#\n########\n\n46\n########\n##..####\n##....##\n###o#.##\n#O#.#..#\n#x...#.#\n#OI....#\n########\n\n47\n########\n##..####\n##....##\n###I#.##\n#O#o#..#\n#x...#.#\n#O.....#\n########\n\n48\n########\n##..####\n##....##\n###.#.##\n#O#I#..#\n#x.o.#.#\n#O.....#\n########\n\n49\n########\n##..####\n##....##\n###.#.##\n#O#.#..#\n#xoI.#.#\n#O.....#\n########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.in", "content": "7 10\r\n##########\r\n##.....###\r\n##o###...#\r\n#.I.o..o.#\r\n#.xx#.o.##\r\n##xx#...##\r\n##########\r\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.out", "content": "88\n##########\n##.....###\n##o###...#\n#...Io.o.#\n#.xx#.o.##\n##xx#...##\n##########\n\n89\n##########\n##.....###\n##o###...#\n#....Ioo.#\n#.xx#.o.##\n##xx#...##\n##########\n\n90\n##########\n##.....###\n##o###.o.#\n#.....oI.#\n#.xx#.o.##\n##xx#...##\n##########\n\n91\n##########\n##.....###\n##o###.o.#\n#....oI..#\n#.xx#.o.##\n##xx#...##\n##########\n\n92\n##########\n##.....###\n##I###.o.#\n#.o..o...#\n#.xx#.o.##\n##xx#...##\n##########\n\n93\n##########\n##.....###\n##.###.o.#\n#.I..o...#\n#.Ox#.o.##\n##xx#...##\n##########\n\n94\n##########\n##.....###\n##.###.o.#\n#....o...#\n#.Ix#.o.##\n##Ox#...##\n##########\n\n95\n##########\n##.....###\n##.###.o.#\n#...oI...#\n#.xx#.o.##\n##Ox#...##\n##########\n\n96\n##########\n##.....###\n##.###.o.#\n#..oI....#\n#.xx#.o.##\n##Ox#...##\n##########\n\n97\n##########\n##.....###\n##.###.o.#\n#.oI.....#\n#.xx#.o.##\n##Ox#...##\n##########\n\n98\n##########\n##.....###\n##.###.o.#\n#.I......#\n#.Ox#.o.##\n##Ox#...##\n##########\n\n99\n##########\n##.....###\n##.###.o.#\n#........#\n#.IO#.o.##\n##Ox#...##\n##########\n\n100\n##########\n##.....###\n##.###oI.#\n#........#\n#.xO#.o.##\n##Ox#...##\n##########\n\n101\n##########\n##.....###\n##.###I..#\n#.....o..#\n#.xO#.o.##\n##Ox#...##\n##########\n\n102\n##########\n##.....###\n##.###...#\n#....oI..#\n#.xO#.o.##\n##Ox#...##\n##########\n\n103\n##########\n##.....###\n##.###...#\n#...oI...#\n#.xO#.o.##\n##Ox#...##\n##########\n\n104\n##########\n##.....###\n##.###...#\n#..oI....#\n#.xO#.o.##\n##Ox#...##\n##########\n\n105\n##########\n##.....###\n##.###...#\n#.oI.....#\n#.xO#.o.##\n##Ox#...##\n##########\n\n106\n##########\n##.....###\n##.###...#\n#.o......#\n#.xI#.o.##\n##OO#...##\n##########\n\n107\n##########\n##.....###\n##.###...#\n#.I......#\n#.Ox#.o.##\n##OO#...##\n##########\n\n108\n##########\n##.....###\n##.###...#\n#........#\n#.IO#.o.##\n##OO#...##\n##########\n\n109\n##########\n##.....###\n##.###...#\n#.....o..#\n#.xO#.I.##\n##OO#...##\n##########\n\n110\n##########\n##.....###\n##.###...#\n#....oI..#\n#.xO#...##\n##OO#...##\n##########\n\n111\n##########\n##.....###\n##.###...#\n#...oI...#\n#.xO#...##\n##OO#...##\n##########\n\n112\n##########\n##.....###\n##.###...#\n#..oI....#\n#.xO#...##\n##OO#...##\n##########\n\n113\n##########\n##.....###\n##.###...#\n#.oI.....#\n#.xO#...##\n##OO#...##\n##########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-05.sol", "content": "88\n##########\n##.....###\n##o###...#\n#...Io.o.#\n#.xx#.o.##\n##xx#...##\n##########\n\n89\n##########\n##.....###\n##o###...#\n#....Ioo.#\n#.xx#.o.##\n##xx#...##\n##########\n\n90\n##########\n##.....###\n##o###.o.#\n#.....oI.#\n#.xx#.o.##\n##xx#...##\n##########\n\n91\n##########\n##.....###\n##o###.o.#\n#....oI..#\n#.xx#.o.##\n##xx#...##\n##########\n\n92\n##########\n##.....###\n##I###.o.#\n#.o..o...#\n#.xx#.o.##\n##xx#...##\n##########\n\n93\n##########\n##.....###\n##.###.o.#\n#.I..o...#\n#.Ox#.o.##\n##xx#...##\n##########\n\n94\n##########\n##.....###\n##.###.o.#\n#....o...#\n#.Ix#.o.##\n##Ox#...##\n##########\n\n95\n##########\n##.....###\n##.###.o.#\n#...oI...#\n#.xx#.o.##\n##Ox#...##\n##########\n\n96\n##########\n##.....###\n##.###.o.#\n#..oI....#\n#.xx#.o.##\n##Ox#...##\n##########\n\n97\n##########\n##.....###\n##.###.o.#\n#.oI.....#\n#.xx#.o.##\n##Ox#...##\n##########\n\n98\n##########\n##.....###\n##.###.o.#\n#.I......#\n#.Ox#.o.##\n##Ox#...##\n##########\n\n99\n##########\n##.....###\n##.###.o.#\n#........#\n#.IO#.o.##\n##Ox#...##\n##########\n\n100\n##########\n##.....###\n##.###oI.#\n#........#\n#.xO#.o.##\n##Ox#...##\n##########\n\n101\n##########\n##.....###\n##.###I..#\n#.....o..#\n#.xO#.o.##\n##Ox#...##\n##########\n\n102\n##########\n##.....###\n##.###...#\n#....oI..#\n#.xO#.o.##\n##Ox#...##\n##########\n\n103\n##########\n##.....###\n##.###...#\n#...oI...#\n#.xO#.o.##\n##Ox#...##\n##########\n\n104\n##########\n##.....###\n##.###...#\n#..oI....#\n#.xO#.o.##\n##Ox#...##\n##########\n\n105\n##########\n##.....###\n##.###...#\n#.oI.....#\n#.xO#.o.##\n##Ox#...##\n##########\n\n106\n##########\n##.....###\n##.###...#\n#.o......#\n#.xI#.o.##\n##OO#...##\n##########\n\n107\n##########\n##.....###\n##.###...#\n#.I......#\n#.Ox#.o.##\n##OO#...##\n##########\n\n108\n##########\n##.....###\n##.###...#\n#........#\n#.IO#.o.##\n##OO#...##\n##########\n\n109\n##########\n##.....###\n##.###...#\n#.....o..#\n#.xO#.I.##\n##OO#...##\n##########\n\n110\n##########\n##.....###\n##.###...#\n#....oI..#\n#.xO#...##\n##OO#...##\n##########\n\n111\n##########\n##.....###\n##.###...#\n#...oI...#\n#.xO#...##\n##OO#...##\n##########\n\n112\n##########\n##.....###\n##.###...#\n#..oI....#\n#.xO#...##\n##OO#...##\n##########\n\n113\n##########\n##.....###\n##.###...#\n#.oI.....#\n#.xO#...##\n##OO#...##\n##########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.in", "content": "13 11\r\n###########\r\n########I.#\r\n########..#\r\n####......#\r\n#...x###.##\r\n#.#.#....##\r\n#.#.o.o#x.#\r\n#.#..O..#.#\r\n#.x#o.o.#.#\r\n##....#.#.#\r\n##.###x...#\r\n##.....####\r\n###########\r\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.out", "content": "" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-06.sol", "content": "107\n###########\n########..#\n########..#\n####......#\n#...x###.##\n#.#.#....##\n#.#oI.o#x.#\n#.#..O..#.#\n#.x#o.o.#.#\n##....#.#.#\n##.###x...#\n##.....####\n###########\n\n108\n###########\n########..#\n########..#\n####......#\n#...x###.##\n#.#.#....##\n#.#o..o#x.#\n#.#..O..#.#\n#.x#I.o.#.#\n##..o.#.#.#\n##.###x...#\n##.....####\n###########\n\n109\n###########\n########..#\n########..#\n####......#\n#...x###.##\n#.#.#....##\n#.#o..o#x.#\n#.#..O..#.#\n#.x#..o.#.#\n##.oI.#.#.#\n##.###x...#\n##.....####\n###########\n\n110\n###########\n########..#\n########..#\n####......#\n#...x###.##\n#.#o#....##\n#.#I..o#x.#\n#.#..O..#.#\n#.x#..o.#.#\n##.o..#.#.#\n##.###x...#\n##.....####\n###########\n\n111\n###########\n########..#\n########..#\n####......#\n#..ox###.##\n#.#I#....##\n#.#...o#x.#\n#.#..O..#.#\n#.x#..o.#.#\n##.o..#.#.#\n##.###x...#\n##.....####\n###########\n\n112\n###########\n########..#\n########..#\n####......#\n#..ox###.##\n#.#.#....##\n#.#...o#x.#\n#.#..I..#.#\n#.x#.oo.#.#\n##.o..#.#.#\n##.###x...#\n##.....####\n###########\n\n113\n###########\n########..#\n########..#\n####......#\n#..IO###.##\n#.#.#....##\n#.#...o#x.#\n#.#..x..#.#\n#.x#.oo.#.#\n##.o..#.#.#\n##.###x...#\n##.....####\n###########\n\n114\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#....##\n#.#...o#x.#\n#.#..x..#.#\n#.x#.oo.#.#\n##oI..#.#.#\n##.###x...#\n##.....####\n###########\n\n115\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#....##\n#.#...o#x.#\n#.#..x..#.#\n#.O#.oo.#.#\n##I...#.#.#\n##.###x...#\n##.....####\n###########\n\n116\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#....##\n#.#...o#x.#\n#.#..O..#.#\n#.O#.Io.#.#\n##....#.#.#\n##.###x...#\n##.....####\n###########\n\n117\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#....##\n#.#...o#x.#\n#.#..O..#.#\n#.O#..Io#.#\n##....#.#.#\n##.###x...#\n##.....####\n###########\n\n118\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#....##\n#.#...o#x.#\n#.#..O..#.#\n#.O#...I#.#\n##....#o#.#\n##.###x...#\n##.....####\n###########\n\n119\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#....##\n#.#...o#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#I#.#\n##.###xo..#\n##.....####\n###########\n\n120\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#....##\n#.#...o#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###OI..#\n##.....####\n###########\n\n121\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#.o..##\n#.#...I#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n122\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#.Io.##\n#.#....#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n123\n###########\n########..#\n########..#\n####......#\n#...O###.##\n#.#.#..Io##\n#.#....#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n124\n###########\n########..#\n########..#\n####......#\n#...O###o##\n#.#.#...I##\n#.#....#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n125\n###########\n########..#\n########..#\n####....o.#\n#...O###I##\n#.#.#....##\n#.#....#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n126\n###########\n########..#\n########o.#\n####....I.#\n#...O###.##\n#.#.#....##\n#.#....#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n127\n###########\n########..#\n########I.#\n####....o.#\n#...O###.##\n#.#.#....##\n#.#....#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n128\n###########\n########..#\n########..#\n####....I.#\n#...O###o##\n#.#.#....##\n#.#....#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n129\n###########\n########..#\n########..#\n####......#\n#...O###I##\n#.#.#...o##\n#.#....#x.#\n#.#..O..#.#\n#.O#....#.#\n##....#.#.#\n##.###O...#\n##.....####\n###########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.in", "content": "8 9\r\n#########\r\n###..#.I#\r\n##...#..#\r\n##o.o.o.#\r\n##.o##..#\r\n##.o.#.##\r\nxxxxx..##\r\n#########\r\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-07.sol", "content": "50\n#########\n###..#..#\n##...#..#\n##o.o.o.#\n##.o##..#\n##oI.#.##\nxxxxx..##\n#########\n\n51\n#########\n###..#..#\n##...#..#\n##ooo.o.#\n##.I##..#\n##o..#.##\nxxxxx..##\n#########\n\n52\n#########\n###..#..#\n##.o.#..#\n##oIo.o.#\n##..##..#\n##o..#.##\nxxxxx..##\n#########\n\n53\n#########\n###..#..#\n##.o.#..#\n##o.Ioo.#\n##..##..#\n##o..#.##\nxxxxx..##\n#########\n\n54\n#########\n###..#..#\n##.I.#..#\n##oo.oo.#\n##..##..#\n##o..#.##\nxxxxx..##\n#########\n\n55\n#########\n###..#..#\n##...#..#\n##oI.oo.#\n##.o##..#\n##o..#.##\nxxxxx..##\n#########\n\n56\n#########\n###..#..#\n##...#..#\n##o..oo.#\n##.I##..#\n##oo.#.##\nxxxxx..##\n#########\n\n57\n#########\n###..#..#\n##...#..#\n##o..oo.#\n##..##..#\n##oI.#.##\nxxxOx..##\n#########\n\n58\n#########\n###..#..#\n##...#..#\n##o..oo.#\n##..##..#\n##o..#.##\nxxOIx..##\n#########\n\n59\n#########\n###..#..#\n##...#..#\n##o..oo.#\n##..##..#\n##o..#.##\nxOIxx..##\n#########\n\n60\n#########\n###..#..#\n##...#..#\n##o..oo.#\n##..##..#\n##o..#.##\nOIxxx..##\n#########\n\n61\n#########\n###..#..#\n##...#..#\n##o..oo.#\n##..##..#\n##I..#.##\nOxOxx..##\n#########\n\n62\n#########\n###..#..#\n##...#..#\n##o..oo.#\n##..##..#\n##...#.##\nOOIxx..##\n#########\n\n63\n#########\n###..#..#\n##...#o.#\n##o..oI.#\n##..##..#\n##...#.##\nOOxxx..##\n#########\n\n64\n#########\n###..#..#\n##...#o.#\n##o.oI..#\n##..##..#\n##...#.##\nOOxxx..##\n#########\n\n65\n#########\n###..#..#\n##...#o.#\n##ooI...#\n##..##..#\n##...#.##\nOOxxx..##\n#########\n\n66\n#########\n###..#..#\n##...#o.#\n##oI....#\n##.o##..#\n##...#.##\nOOxxx..##\n#########\n\n67\n#########\n###..#..#\n##...#o.#\n##o.....#\n##.I##..#\n##.o.#.##\nOOxxx..##\n#########\n\n68\n#########\n###..#..#\n##...#o.#\n##o.....#\n##..##..#\n##.I.#.##\nOOxOx..##\n#########\n\n69\n#########\n###..#..#\n##...#o.#\n##o.....#\n##..##..#\n##...#.##\nOOxIO..##\n#########\n\n70\n#########\n###..#..#\n##...#I.#\n##o...o.#\n##..##..#\n##...#.##\nOOxxO..##\n#########\n\n71\n#########\n###..#..#\n##...#..#\n##o..oI.#\n##..##..#\n##...#.##\nOOxxO..##\n#########\n\n72\n#########\n###..#..#\n##...#..#\n##o.oI..#\n##..##..#\n##...#.##\nOOxxO..##\n#########\n\n73\n#########\n###..#..#\n##...#..#\n##ooI...#\n##..##..#\n##...#.##\nOOxxO..##\n#########\n\n74\n#########\n###..#..#\n##...#..#\n##oI....#\n##.o##..#\n##...#.##\nOOxxO..##\n#########\n\n75\n#########\n###..#..#\n##...#..#\n##o.....#\n##.I##..#\n##.o.#.##\nOOxxO..##\n#########\n\n76\n#########\n###..#..#\n##...#..#\n##o.....#\n##..##..#\n##.I.#.##\nOOxOO..##\n#########\n\n77\n#########\n###..#..#\n##...#..#\n##I.....#\n##o.##..#\n##...#.##\nOOxOO..##\n#########\n\n78\n#########\n###..#..#\n##...#..#\n##......#\n##I.##..#\n##o..#.##\nOOxOO..##\n#########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.in", "content": "7 10\n##########\n####....##\n##x.o##.##\n#xxo.o..I#\n#xx.o.o.##\n#####...##\n##########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-08.sol", "content": "29\n##########\n####....##\n##x.o##.##\n#xxooI...#\n#xx.o.o.##\n#####...##\n##########\n\n30\n##########\n####....##\n##x.o##.##\n#xxoo....#\n#xxoI.o.##\n#####...##\n##########\n\n31\n##########\n####....##\n##x.o##.##\n#xxoo....#\n#xOI..o.##\n#####...##\n##########\n\n32\n##########\n####....##\n##xoo##.##\n#xxIo....#\n#xO...o.##\n#####...##\n##########\n\n33\n##########\n####....##\n##xoo##.##\n#xx.o....#\n#OI...o.##\n#####...##\n##########\n\n34\n##########\n####....##\n##xoo##.##\n#xxoI....#\n#Ox...o.##\n#####...##\n##########\n\n35\n##########\n####....##\n##xoo##.##\n#xOI.....#\n#Ox...o.##\n#####...##\n##########\n\n36\n##########\n####....##\n##xoI##.##\n#xO.o....#\n#Ox...o.##\n#####...##\n##########\n\n37\n##########\n####....##\n##OI.##.##\n#xO.o....#\n#Ox...o.##\n#####...##\n##########\n\n38\n##########\n####....##\n##O..##.##\n#OI.o....#\n#Ox...o.##\n#####...##\n##########\n\n39\n##########\n####....##\n##O..##.##\n#OxoI....#\n#Ox...o.##\n#####...##\n##########\n\n40\n##########\n####....##\n##O..##.##\n#OOI.....#\n#Ox...o.##\n#####...##\n##########\n\n41\n##########\n####....##\n##O..##.##\n#OO......#\n#Ox..oI.##\n#####...##\n##########\n\n42\n##########\n####....##\n##O..##.##\n#OO......#\n#Ox.oI..##\n#####...##\n##########\n\n43\n##########\n####....##\n##O..##.##\n#OO......#\n#OxoI...##\n#####...##\n##########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.in", "content": "9 11\n###########\n##..##...##\n##...o...##\n##o.###.o##\n##.#xxx#.##\n##.#xxx#.##\n#.o..o..o.#\n#.....#.I.#\n###########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk01-09.sol", "content": "130\n###########\n##..##...##\n##...o...##\n##o.###.o##\n##.#xxx#.##\n##.#xOx#.##\n#.o..I..o.#\n#.....#...#\n###########\n\n131\n###########\n##..##...##\n##...o...##\n##o.###.o##\n##.#xxx#.##\n##.#xIO#.##\n#.o.....o.#\n#.....#...#\n###########\n\n132\n###########\n##..##...##\n##...o...##\n##o.###.o##\n##.#xxx#.##\n##.#xxO#.##\n#.o....oI.#\n#.....#...#\n###########\n\n133\n###########\n##..##...##\n##...o...##\n##o.###.o##\n##.#xxx#.##\n##.#xxO#.##\n#.o...oI..#\n#.....#...#\n###########\n\n134\n###########\n##..##...##\n##...o...##\n##o.###.o##\n##.#xxx#.##\n##.#xxO#.##\n#.o..oI...#\n#.....#...#\n###########\n\n135\n###########\n##..##...##\n##...o...##\n##o.###.o##\n##.#xxO#.##\n##.#xxI#.##\n#.o..o....#\n#.....#...#\n###########\n\n136\n###########\n##..##...##\n##...o...##\n##o.###.o##\n##.#xxO#.##\n##.#xxx#.##\n#.Io.o....#\n#.....#...#\n###########\n\n137\n###########\n##..##...##\n##o..o...##\n##I.###.o##\n##.#xxO#.##\n##.#xxx#.##\n#..o.o....#\n#.....#...#\n###########\n\n138\n###########\n##..##...##\n##o..Io..##\n##..###.o##\n##.#xxO#.##\n##.#xxx#.##\n#..o.o....#\n#.....#...#\n###########\n\n139\n###########\n##..##...##\n##o...Io.##\n##..###.o##\n##.#xxO#.##\n##.#xxx#.##\n#..o.o....#\n#.....#...#\n###########\n\n140\n###########\n##..##...##\n##o....o.##\n##..###.I##\n##.#xxO#o##\n##.#xxx#.##\n#..o.o....#\n#.....#...#\n###########\n\n141\n###########\n##..##...##\n##o....o.##\n##..###..##\n##.#xxO#I##\n##.#xxx#o##\n#..o.o....#\n#.....#...#\n###########\n\n142\n###########\n##..##...##\n##o....o.##\n##..###..##\n##.#xxO#.##\n##.#xxx#I##\n#..o.o..o.#\n#.....#...#\n###########\n\n143\n###########\n##..##...##\n##o....Io##\n##..###..##\n##.#xxO#.##\n##.#xxx#.##\n#..o.o..o.#\n#.....#...#\n###########\n\n144\n###########\n##..##...##\n##o.....o##\n##..###..##\n##.#xxO#.##\n##.#xxx#.##\n#..Ioo..o.#\n#.....#...#\n###########\n\n145\n###########\n##..##...##\n##o.....o##\n##..###..##\n##.#xxO#.##\n##.#Oxx#.##\n#...Io..o.#\n#.....#...#\n###########\n\n146\n###########\n##..##...##\n##o.....o##\n##..###..##\n##.#xxO#.##\n##.#OOx#.##\n#....I..o.#\n#.....#...#\n###########\n\n147\n###########\n##..##...##\n##o.....o##\n##..###..##\n##.#OxO#.##\n##.#IOx#.##\n#.......o.#\n#.....#...#\n###########\n\n148\n###########\n##..##...##\n##o.....o##\n##..###..##\n##.#OxO#.##\n##.#xIO#.##\n#.......o.#\n#.....#...#\n###########\n\n149\n###########\n##..##...##\n##o.....o##\n##..###..##\n##.#OxO#.##\n##.#xxO#.##\n#......oI.#\n#.....#...#\n###########\n\n150\n###########\n##..##...##\n##o.....o##\n##..###..##\n##.#OxO#.##\n##.#xxO#.##\n#.....oI..#\n#.....#...#\n###########\n\n151\n###########\n##..##...##\n##o.....o##\n##..###..##\n##.#OxO#.##\n##.#xxO#.##\n#....oI...#\n#.....#...#\n###########\n\n152\n###########\n##..##...##\n##o.....I##\n##..###.o##\n##.#OxO#.##\n##.#xxO#.##\n#....o....#\n#.....#...#\n###########\n\n153\n###########\n##..##...##\n##o......##\n##..###.I##\n##.#OxO#o##\n##.#xxO#.##\n#....o....#\n#.....#...#\n###########\n\n154\n###########\n##..##...##\n##o......##\n##..###..##\n##.#OxO#I##\n##.#xxO#o##\n#....o....#\n#.....#...#\n###########\n\n155\n###########\n##..##...##\n##o......##\n##..###..##\n##.#OxO#.##\n##.#xxO#I##\n#....o..o.#\n#.....#...#\n###########\n\n156\n###########\n##..##...##\n##o......##\n##..###..##\n##.#OxO#.##\n##.#xOO#.##\n#....I..o.#\n#.....#...#\n###########\n\n157\n###########\n##..##...##\n##o......##\n##..###..##\n##.#OxO#.##\n##.#xOO#.##\n#......oI.#\n#.....#...#\n###########\n\n158\n###########\n##..##...##\n##I......##\n##o.###..##\n##.#OxO#.##\n##.#xOO#.##\n#......o..#\n#.....#...#\n###########\n\n159\n###########\n##..##...##\n##.......##\n##I.###..##\n##o#OxO#.##\n##.#xOO#.##\n#......o..#\n#.....#...#\n###########\n\n160\n###########\n##..##...##\n##.......##\n##..###..##\n##I#OxO#.##\n##o#xOO#.##\n#......o..#\n#.....#...#\n###########\n\n161\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OxO#.##\n##I#xOO#.##\n#.o....o..#\n#.....#...#\n###########\n\n162\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OxO#.##\n##.#xOO#.##\n#.o...oI..#\n#.....#...#\n###########\n\n163\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OxO#.##\n##.#xOO#.##\n#.o..oI...#\n#.....#...#\n###########\n\n164\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OxO#.##\n##.#xOO#.##\n#.o.oI....#\n#.....#...#\n###########\n\n165\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OOO#.##\n##.#xIO#.##\n#.o.o.....#\n#.....#...#\n###########\n\n166\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OOO#.##\n##.#OxO#.##\n#.o.I.....#\n#.....#...#\n###########\n\n167\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OOO#.##\n##.#OxO#.##\n#.Io......#\n#.....#...#\n###########\n\n168\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OOO#.##\n##.#OxO#.##\n#..Io.....#\n#.....#...#\n###########\n\n169\n###########\n##..##...##\n##.......##\n##..###..##\n##.#OOO#.##\n##.#OxO#.##\n#...Io....#\n#.....#...#\n###########\n\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.in", "content": "7 8\r\n########\r\n#..#...#\r\n#.oxxo.#\r\n#IoxO.##\r\n#.oxxo.#\r\n#..#...#\r\n########\r\n" }, { "path": "other-languages/ai/sokoban/sokobanonline/classic/thinkingrabbit/Boxxle/sk02-10.sol", "content": "41\n########\n#..#...#\n#.IOxo.#\n#.oxO.##\n#.oxxo.#\n#..#...#\n########\n\n42\n########\n#..#...#\n#..Oxo.#\n#.oxO.##\n#.IOxo.#\n#..#...#\n########\n\n43\n########\n#..#...#\n#.oOxo.#\n#.IxO.##\n#..Oxo.#\n#..#...#\n########\n\n44\n########\n#..#...#\n#.oOxo.#\n#..xIo##\n#..Oxo.#\n#..#...#\n########\n\n45\n########\n#..#...#\n#.oOxo.#\n#..xxo##\n#.oIxo.#\n#..#...#\n########\n\n46\n########\n#..#...#\n#.oOxo.#\n#..xxo##\n#.oxOI.#\n#..#...#\n########\n\n47\n########\n#..#...#\n#.oOxo.#\n#..xxo##\n#.oOI..#\n#..#...#\n########\n\n48\n########\n#..#...#\n#.oOOI.#\n#..xxo##\n#.oOx..#\n#..#...#\n########\n\n49\n########\n#..#...#\n#.oOO..#\n#..xxI##\n#.oOxo.#\n#..#...#\n########\n\n50\n########\n#..#...#\n#.oOO..#\n#..xx.##\n#.oOOI.#\n#..#...#\n########\n\n51\n########\n#..#...#\n#.IOO..#\n#.oxx.##\n#.oOO..#\n#..#...#\n########\n\n52\n########\n#..#...#\n#..OO..#\n#.IOx.##\n#.oOO..#\n#..#...#\n########\n\n53\n########\n#..#...#\n#..OO..#\n#..IO.##\n#.oOO..#\n#..#...#\n########\n\n54\n########\n#..#...#\n#..OO..#\n#.oxO.##\n#.IOO..#\n#..#...#\n########\n\n" }, { "path": "other-languages/ai/sudoku/sudoku.cpp", "content": "/*\n# -*- coding: utf-8 -*-\n\n\"\"\"\nBacktracking e Heurísticas aplicadas para se resolver um sudoku.\nA busca é feita no grafo de estados do problema\nAutores: \n ? \nColaborador:\n \tPéricles Lopes Machado [gogo40] (pericles.raskolnikoff.gmail.com)\nTipo: \n search\nDescrição: \n Sudokus são problema NP-difíceis, por isso na maior parte\ndo tempo procuramos heurísticas que acelerem a busca. Nesse código\nsão implementadas algumas heurísticas humanas, como limitar as opções\nde jogada em cada estado usando as regras do jogo.\n\tExiste uma solução mais eficiente utilizando-se o algoritmo X[5].\nFuturamente, planejo implementar essa outra abordagem. Este código\né apenas um exemplo de como heurísticas podem acelerar a busca de uma solução de sudoku.\n\nComplexidade: \n O(2^N)\nDificuldade: \n Difícil\nReferências:\n [1] http://en.wikipedia.org/wiki/Backtracking\n [2] http://en.wikipedia.org/wiki/Heuristic\n\t[3] http://falapericles.blogspot.com.br/2009/05/grafo-de-estados-e-suas-aplicacoes.html\n\t[4] http://webdocs.cs.ualberta.ca/~games/Sokoban/\n\t[5] http://en.wikipedia.org/wiki/Knuth%27s_Algorithm_X\n\"\"\"\n*/\n\n\n/*\nPara testar o código pode-se utilizar o seguinte problema do SPOJ brasil:\n\nhttp://br.spoj.com/problems/BSUDO/\n\nOu digitar no terminal a seguinte entrada (test_001.in):\n1\n103000509\n002109400\n000704000\n300502006\n060000050\n700803004\n000401000\n009205800\n804000107\n\nO '0' representa uma posição vaga na grade\n\nEste algoritmo é bem eficiente para o caso 9x9, mas para o caso 16x16 ainda é preciso melhorias.\nO algoritmo X do Knuth é mais eficiente, mas é um pouco mais complexo.\n*/\n#include \n\n#define INF 500\n\nusing namespace std;\n\n\n/*vetor de palavras com tamanho menor que 32 bits**/\ntypedef long long lint;\ntypedef unsigned long long ulint;\n\n/*Esta estrtura representa um nó no grafo de estados do problema*/\nstruct V{\n\t//tam_word=9 NMAX=20;\n\t//n_words=64/9 numero de palavras por chunck\n\t\n\tint n_words, nbits, MASK;\n\t\n\tulint v[6];\n\tulint mask;\n\t\n\tV(int n_words=5,int nbits=10, int MASK=1023)\n\t:n_words(n_words),nbits(nbits),mask(MASK){\n\t\tfor(int i=0;i<6;i++) v[i]=0;\n\t}\n\t\n\tV(const V& b){\n\t\tn_words=b.n_words; nbits=b.nbits;\n\t\tMASK=b.MASK; mask=b.mask;\n\t\tfor(int i=0;i<6;i++) v[i]=b.v[i];\n\t}\n\t\n\tinline\n\tvoid insert(int p, ulint V){\n\t\tint i;\n\t\t\n\t\ti=p/n_words;\n\t\tp=p%n_words;\n\t\t\n\t\tp*=nbits;\n\t\t\n\t\tv[i]=(v[i]^(v[i] & (mask<>p)&mask);\n\t}\n\t\n\tV& operator=(const V& b){\n\t\tn_words=b.n_words; nbits=b.nbits;\n\t\tMASK=b.MASK; mask=b.mask;\n\t\tfor(int i=0;i<6;i++) v[i]=b.v[i];\n\t\treturn *this;\n\t}\n\n};\n\n/****************************/\n\n\n//Armazena estado anterior\nstruct st{\n\tV s, pl, pc, ps;//estado anterior\n\tint le, x, y;//ultima escolha e posicao onde ocorreu\n\t\n\tst():s(16,4,15),pl(),pc(),ps(),le(1),x(0),y(0){}\n\t\n\tst(const V& s, const V& pl, const V& pc, const V& ps, int le=1, int x=0, int y=0)\n\t:s(s),pl(pl),pc(pc),ps(ps),le(le),x(x),y(y){}\n\t\n\tst& operator=(const st& a){\n\t\ts=a.s; pl=a.pl; pc=a.pc; ps=a.ps;\n\t\tle=a.le; x=a.x; y=a.y;\n\t\treturn *this;\n\t}\n};\n\n\n/*Pilha de estados*/\nstatic st Q[81];\nint ip;\nstatic int hel[10];\nstatic int lg[1<<10];\nstatic int ones[1<<10];\nstatic const ulint inf=~(0LL);\n\n// Imprime solução\ninline\nvoid print(V& sol)\n{\n\tint i, j;\n\tfor(i=0;i<9;i++){\n\t\tfor(j=0;j<9;j++) printf(\"%d\",sol.get(i*9+j));\n\t\tprintf(\"\\n\");\n\t}\n}\n\n/*Função de backtracking que explora a arvore de possibilidades do jogo*/\n\nbool solve(V& s){\n\tV podeLin, podeCol, podeSet;\n\tint i, j, x, y, a, b, set;\n\tint px, py, mi, l, ns;\n\tbool ok;\n\n\t/*Inicializa opções para cada linha coluna e setor*/\n\tfor(i=0;i<2;i++) podeCol.v[i]=podeSet.v[i]=podeLin.v[i]=inf;\n\t\n\tok=true;\n\tip=0;\n\tint np=0;\n\tfor(;;){\n\t\n\t\t//Verifica se já resolvi o sudoku s\n\t\t//print(s);\n\t\tinit:\n\t\tnp++;\n\t\t//Caso não foi possível realizar uma jogada na iteração anterior desempilha-se um estado da pilha\n\t\tif(!ok)\n\t\t\tfor(;;){\n\t\t\t\tip--;\n\t\t\t\t\n\t\t\t\t/*Se já tentei todas opções da pilha e mesmo assim não resolvi o sudoku, \n\t\t\t\tentão o sudoku não tem solução*/\n\t\t\t\tif(ip==-1) return false;\n\t\t\t\telse{\n\t\t\t\t\t/*Desempilho um ramo que \n\t\t\t\t\tpode conter uma solução*/\n\t\t\t\t\ts=Q[ip].s;\n\t\t\t\t\t/*Recupero opções pra linha, coluna e setor*/\n\t\t\t\t\tpodeLin=Q[ip].pl; podeCol=Q[ip].pc; podeSet=Q[ip].ps;\n\n\t\t\t\t\t/*Posição de referencia utilizada para fazer a busca*/\n\t\t\t\t\tpx=i=Q[ip].x; py=j=Q[ip].y;\n\t\t\t\t\t\n\t\t\t\t\ta=(i/3); b=(j/3); set=a*3+b;\n\t\t\t\t\ty=podeLin.get(i); y&=podeCol.get(j); y&=podeSet.get(set); \n\t\t\t\t\t\n\t\t\t\t\tfor(i=Q[ip].le+1;i<10;i++)\n\t\t\t\t\t\tif((y>>i)&0x1){\n\t\t\t\t\t\t\t/*Empilho opções restantes*/\n\t\t\t\t\t\t\tQ[ip]=st(s,podeLin,podeCol,podeSet,i,px,py);\n\t\t\t\t\t\t\tip++;\n\t\t\t\t\t\t\ts.insert(px*9+py,i);\n\t\t\t\t\t\t\tgoto cont;//Preciso sair desse mais aninhado\n\t\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\tcont:\n\t\t\n\t\t//Realiza travas e procura posições que tem opcoes unicas\n\t\tns=0;\n\t\tfor(i=0;i<9;i++)\n\t\t\tfor(j=0;j<9;j++){\n\t\t\t\tx=s.get(i*9+j);\n\t\t\t\ta=(i/3); b=(j/3); set=a*3+b;\n\t\t\t\t\t\n\t\t\t\tif(x>0){\n\t\t\t\t\tns++;\n\t\t\t\t\t//Atualiza opções pra linha\n\t\t\t\t\ty=podeLin.get(i); y&=hel[x]; podeLin.insert(i,y);\n\t\t\t\t\t//Atualiza opções pra coluna\n\t\t\t\t\ty=podeCol.get(j); y&=hel[x]; podeCol.insert(j,y);\n\t\t\t\t\t//Atualiza opções pro setor\n\t\t\t\t\ty=podeSet.get(set); y&=hel[x]; podeSet.insert(set,y);\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\t/*Caso eu já tenha preenchido todas 81 casas, então eu resolvi o sudoku*/\n\t\tif(ns==81){ print(s); return true; }\n\t\t\n\t\t/* Atualiza opções para cada linha e coluna*/\n\t\tmi=INF; ok=false;\n\t\tfor(i=0;i<9;i++)\n\t\t\tfor(j=0;j<9;j++){\t\n\t\t\t\tx=s.get(i*9+j);\n\t\t\t\ta=(i/3); b=(j/3); set=a*3+b;\n\t\t\t\t\t\n\t\t\t\tif(x==0){\n\t\t\t\t\ty=podeLin.get(i); y&=podeCol.get(j); y&=podeSet.get(set); \n\t\t\t\t\tx=lg[y];\n\t\t\t\t\tif(x>0){\n\t\t\t\t\t\t/*Insere possivel valor pra posição i, j da grade*/\n\t\t\t\t\t\ts.insert(i*9+j,x);\n\t\t\t\t\t\t/*bloqueia x como opção para linha i, coluna j e setor set*/\n\t\t\t\t\t\ty=podeLin.get(i); y&=hel[x]; podeLin.insert(i,y);\n\t\t\t\t\t\ty=podeCol.get(j); y&=hel[x]; podeCol.insert(j,y);\n\t\t\t\t\t\ty=podeSet.get(set); y&=hel[x]; podeSet.insert(set,y);\n\t\t\t\t\t\tok=true;\n\t\t\t\t\t}else if(y==0) goto init; \n\t\t\t\t\telse{\n\t\t\t\t\t\t/*opções pra pra posição i, j*/\n\t\t\t\t\t\tx=ones[y]; \n\t\t\t\t\t\tif(x>i)&0x1){\n\t\t\t\t\tQ[ip]=st(s,podeLin,podeCol,podeSet,i,px,py);\n\t\t\t\t\tip++;\n\t\t\t\t\ts.insert(px*9+py,i);\n\t\t\t\t\tok=true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t}\n\t}\n}\n\n//*********************************************************//\n//MAIN\n//*********************************************************//\n\n/*Verifica é possivel resolver a grade*/\nbool find_error(V& s){\n\tfor(int n=1;n<10;n++){\n\t\tint noc;\n\t\tfor(int i=0;i<9;i++){\n\t\t\tnoc=0;\n\t\t\tfor(int j=0;j<9;j++)\n\t\t\t\tif(s.get(i*9+j)==n) noc++;\n\t\t\tif(noc>1) return false;\n\t\t}\n\t\t\n\t\tfor(int i=0;i<9;i++){\n\t\t\tnoc=0;\n\t\t\tfor(int j=0;j<9;j++)\n\t\t\t\tif(s.get(j*9+i)==n) noc++;\n\t\t\tif(noc>1) return false;\n\t\t}\n\t\t\n\t\tfor(int i=0;i<3;i++){\n\t\t\tint lm=3*(i+1);\n\t\t\tint auxI=3*i;\n\t\t\t\n\t\t\tfor(int j=0;j<3;j++){\n\t\t\t\tint lp=3*(j+1);\n\t\t\t\tnoc=0;\n\t\t\t\t\n\t\t\t\tfor(int m=auxI;m1) return false;\n\t\t\t}\t\n\t\t}\n\t\t\n\t}\n\treturn true;\n}\n\nint main()\n{\n\tint N, x, i, j, len, m,c;\n\tV s(16,4,15);\n\t\n\tlen=1<<10; m=len-1;\n\tfor(i=0;i>j & 0x1)x++;\n\t\tones[i]=x;\n\t}\n\t\n\tfor(i=0;i<10;i++) { \n\t\tlg[1<0) hel[i]--;\n\t}\n\t\n\tc=1;\n\tscanf(\"%d\",&N);\n\twhile(N--){\n\t\tfor(i=0;i<9;i++)\n\t\t\tfor(j=0;j<9;j++){\n\t\t\t\tscanf(\"%1d\",&x);\n\t\t\t\ts.insert(i*9+j,x);\n\t\t\t}\n\t\t\n\t\tif(!find_error(s)) printf(\"Could not complete this grid.\\n\");\n\t\telse if(!solve(s)) printf(\"Could not complete this grid.\\n\");\n\t\tc++;\n\t}\n\treturn 0;\n}\n\n\n\n" }, { "path": "other-languages/ai/sudoku/test_001.in", "content": "1\n103000509\n002109400\n000704000\n300502006\n060000050\n700803004\n000401000\n009205800\n804000107\n\n" }, { "path": "other-languages/array/merge/merge.rb", "content": "\n=begin\n Merge\nAutor:\n ?\nColaborador:\n José Alberto O. Morais Filho (j.moraisg12@gmail.com)\nTipo:\n array-operations\nDescrição:\n Combina dois subvetores (ordernados), gerando um vetor ordenado\nComplexidade:\n O(n)\nDificuldade:\n médio\nReferências:\n [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 29-34)\n=end\n\ndef merge(array, left, mid, right)\n n1 = mid - left + 1\n n2 = right - mid\n\n l = Array.new(n1 + 1) {0}\n r = Array.new(n2 + 1) {0}\n\n for i in 0...n1 do\n l[i] = array[left + i]\n end\n\n for j in 1..n2 do\n r[j - 1] = array[mid + j]\n end\n\n l[n1] = 999999\n r[n2] = 999999\n\n i = 0\n j = 0\n\n for k in left..right do\n if l[i] <= r[j]\n array[k] = l[i]\n i += 1\n else\n array[k] = r[j]\n j += 1\n end\n end\nend\n\n# Exemplos\n\na = [5, 6, 7, 8, 9, 1, 2, 3, 4]\nmerge(a, 0, 4, 8)\nprint a\n\nputs\n\nb = [1, 3, 5, 7, 2, 4, 6, 8]\nmerge(b, 0, 3, 7)\nprint b = right - mid\n\n l = Array.new(n1 + 1) {0}\n r = Array.new(n2 + 1) {0}\n\n for i in 0...n1 do" }, { "path": "other-languages/array/partition/partition.rb", "content": "\n=begin\n Partition\nAutor:\n ?\nColaborador:\n José Alberto O. Morais Filho (j.moraisg12@gmail.com)\nTipo:\n array-operations\nDescrição:\n Reposiciona os valores de um array de tal forma que todos os elementos da esquerda do pivô (ultimo elemento) sejam\n menores que ele e os da direita sejam maiores.\nComplexidade:\n O(n)\nDificuldade:\n médio\nReferências:\n [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 171-172)\n=end\n\n# Entrada:\n# array = um vetor a ser reposicionado;\n# left = primeira posição do vetor (ou subvetor);\n# right = última posição do vetor (ou subvetor);\n# Saída:\n# A posição do pivô no novo vetor\n\ndef partition(array, left, right)\n x = array[right]\n i = left - 1\n\n for j in left...right do\n if array[j] <= x then\n i += 1\n array[i], array[j] = array[j], array[i]\n end\n end\n\n array[i + 1], array[right] = array[right], array[i + 1]\n\n i + 1\n\nend\n\n# Exemplos\na = [2, 8, 7, 1, 3, 5, 6, 4]\nb = [3, 1, 2, 6, 7, 4, 5]\n\nprint(partition a, 0, 7)\nputs\nprint(partition b, 0, 6)or (ou subvetor);\n# right = última posição do vetor (ou subvetor);\n# Saída:\n# A posição do pivô no novo vetor\n\ndef partition(array, left, right)\n x = array[right]\n i = left - 1\n\n for j in left...right do\n if array[j] <= x then\n i += 1\n array[i], array[j] = array[j], array[i]\n end\n end\n\n array[i + 1], array[right] = array[right], array[i + 1]\n\n i + 1\n\nend\n\n# Exemplos\na = [2, 8, 7, 1, 3, 5, 6, 4]\nb = [3, 1, 2, 6, 7, 4, 5]\n\nprint(partit" }, { "path": "other-languages/bitwise/BitScanForwardDebruijn64.cs", "content": "//BitScanForward com De Bruijn (64 bits)\n//Autor:\n// Juan Lopes \n//Tipo:\n// bitwise\n//Descrio:\n// Encontra o ndice do LSB (Least Significant Bit) em O(1)\n//Complexidade: \n// Pior caso: O(1)\n// Melhor caso: O(1)\n//Dificuldade:\n// facil\n//Referncias:\n// http://en.wikipedia.org/wiki/De_Bruijn_sequence\n\nusing System;\n\nnamespace BitScanForwardDebruijn64\n{\n class Program\n {\n static int[] index64 = new[] \n {\n 63, 0, 58, 1, 59, 47, 53, 2,\n 60, 39, 48, 27, 54, 33, 42, 3,\n 61, 51, 37, 40, 49, 18, 28, 20,\n 55, 30, 34, 11, 43, 14, 22, 4,\n 62, 57, 46, 52, 38, 26, 32, 41,\n 50, 36, 17, 19, 29, 10, 13, 21,\n 56, 45, 25, 31, 35, 16, 9, 12,\n 44, 24, 15, 8, 23, 7, 6, 5\n };\n\n public static int BitScanForward(ulong value)\n {\n if (value == 0) return -1;\n const ulong debruijn64 = 0x07EDD5E59A4E28C2ul;\n return index64[((value & (~value + 1)) * debruijn64) >> 58];\n }\n\n static void Main(string[] args)\n {\n Console.WriteLine(BitScanForward(128));\n }\n }\n}\n" }, { "path": "other-languages/bitwise/HammingWeight64.cs", "content": "//Hamming Weight (64 bits)\n//Autor:\n// Juan Lopes \n//Tipo:\n// bitwise\n//Descrio:\n// Conta o nmero de bits ligados\n// em um inteiro de 64 bits.\n//Complexidade: \n// Pior caso: O(1)\n// Melhor caso: O(1)\n//Dificuldade:\n// facil\n//Referncias:\n// http://en.wikipedia.org/wiki/Hamming_weight\n\nusing System;\n\nnamespace HammingWeight64\n{\n class Program\n {\n public static int PopCount(ulong x)\n {\n unchecked\n {\n const ulong h01 = 0x0101010101010101;\n const ulong m1 = 0x5555555555555555;\n const ulong m2 = 0x3333333333333333;\n const ulong m4 = 0x0f0f0f0f0f0f0f0f;\n\n x -= (x >> 1) & m1;\n x = (x & m2) + ((x >> 2) & m2);\n x = (x + (x >> 4)) & m4;\n return (int)((x * h01) >> 56);\n }\n }\n\n static void Main(string[] args)\n {\n Console.WriteLine(PopCount(128));\n }\n }\n}\n" }, { "path": "other-languages/bitwise/bsf-debruijn/BitScanForwardDebruijn64.cs", "content": "//BitScanForward com De Bruijn (64 bits)\n//Autor:\n// Nicolaas Govert de Bruijn\n//Tipo:\n// bitwise\n//Descrio:\n// Encontra o ndice do LSB (Least Significant Bit) em O(1)\n//Complexidade: \n// O(1)\n//Dificuldade:\n// facil\n//Referncias:\n// http://en.wikipedia.org/wiki/De_Bruijn_sequence\n\nusing System;\n\nnamespace BitScanForwardDebruijn64\n{\n class Program\n {\n static int[] index64 = new[] \n {\n 63, 0, 58, 1, 59, 47, 53, 2,\n 60, 39, 48, 27, 54, 33, 42, 3,\n 61, 51, 37, 40, 49, 18, 28, 20,\n 55, 30, 34, 11, 43, 14, 22, 4,\n 62, 57, 46, 52, 38, 26, 32, 41,\n 50, 36, 17, 19, 29, 10, 13, 21,\n 56, 45, 25, 31, 35, 16, 9, 12,\n 44, 24, 15, 8, 23, 7, 6, 5\n };\n\n public static int BitScanForward(ulong value)\n {\n if (value == 0) return -1;\n const ulong debruijn64 = 0x07EDD5E59A4E28C2ul;\n return index64[((value & (~value + 1)) * debruijn64) >> 58];\n }\n\n static void Main(string[] args)\n {\n Console.WriteLine(BitScanForward(128));\n }\n }\n}\n" }, { "path": "other-languages/bitwise/dec2hex/dec2hex.c", "content": "/*\nConversor Decimal/Hexadecimal\nAutor:\n ?\nColaborador:\n Ramon Caldeira Faria (ramoncaldeira_328@hotmail.com)\nTipo:\n bitwise\nDescrição:\n O algoritmo devolve uma string da representação\n hexadecimal de um determinado inteiro de 8 bits.\nComplexidade:\n O(1)\nDificuldade:\n medio\n*/\n\n#include \n\nconst char* HEXA = \"0123456789ABCDEF\";\n\n/* @param dec número no intervalo [0,255] */\nchar* decToHex(unsigned dec) {\n char* hexadecimal = (char*) calloc(3, sizeof(char));\n hexadecimal[0] = HEXA[ (dec & 0xF0) >> 4 ];\n hexadecimal[1] = HEXA[ dec & 0x0F ];\n hexadecimal[2] = '\\0';\n return hexadecimal; \n}\n" }, { "path": "other-languages/bitwise/hamming-weight/HammingWeight64.cs", "content": "//Hamming Weight (64 bits)\n//Autor:\n// ?\n//Tipo:\n// bitwise\n//Descrio:\n// Conta o nmero de bits ligados\n// em um inteiro de 64 bits.\n//Complexidade: \n// O(1)\n//Dificuldade:\n// facil\n//Referncias:\n// http://en.wikipedia.org/wiki/Hamming_weight\n\nusing System;\n\nnamespace HammingWeight64\n{\n class Program\n {\n public static int PopCount(ulong x)\n {\n unchecked\n {\n const ulong h01 = 0x0101010101010101;\n const ulong m1 = 0x5555555555555555;\n const ulong m2 = 0x3333333333333333;\n const ulong m4 = 0x0f0f0f0f0f0f0f0f;\n\n x -= (x >> 1) & m1;\n x = (x & m2) + ((x >> 2) & m2);\n x = (x + (x >> 4)) & m4;\n return (int)((x * h01) >> 56);\n }\n }\n\n static void Main(string[] args)\n {\n Console.WriteLine(PopCount(128));\n }\n }\n}\n" }, { "path": "other-languages/bitwise/operations/operations.cpp", "content": "/*\nOperações bitwise\nAutor:\n ?\nColaborador:\n Ramon Caldeira (ramoncaldeira_328@hotmail.com)\nTipo:\n bitwise\nDescrição:\n Coletânea de algotitmos bitwise.\nComplexidade: \n O(1)\nDificuldade:\n fácil\n*/\n\n/* verifica se um número é par */\nbool isOdd(int num) { return num & 1; }\n\n/* verifica se um número é potência de 2\n ex: 16 = 10000(2)\n 15 = 01111(2)\n => 16 & 15 = 10000 & 01111 = 0\n */\nbool isPower2(int num) { return !(num-1 & num); }\n\n/* permuta case de caractere \n funcionamento: na tabela ASCII\n os caracteres minúsculos se diferenciam dos maiúsculos\n através do 5° bit = 32 = 20(H)\n ex: A(65) a(97) a - A = 32\n*/\nvoid toggleCase(char& ch) { ch ^= 0x20; }\n\n/* seta case maiúsculo */\nvoid toUpper(char& ch) { ch &= ~0x20; }\n\n/* seta case minúsculo */\nvoid toLower(char& ch) { ch |= 0x20; }\n" }, { "path": "other-languages/bitwise/swap_xor/swap_xor.c", "content": "/*\r\nAlgoritimo de troca de variveis\r\nAutor:\r\n ?\r\nColaborador:\r\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\r\nTipo:\r\n bitwise\r\nDescrio:\r\n Algoritimo que tem objetivo de trocar os valores\r\n\tde duas variveis sem o uso de uma varivel temporria\r\n\tusando apenas o operdador boolean \"ou exclusivo\".\r\n\tLembrando que esse algortimo s funciona se as variveis\r\n\ttiverem em locais diferentes na memria\r\nComplexidade:\r\n O(1)\r\nDificuldade:\r\n fcil\r\nReferncias:\r\n\thttp://en.wikipedia.org/wiki/XOR_swap_algorithm\r\n*/\r\n\r\n#include \r\n\r\nvoid swap(int* a, int* b) {\r\n\r\n\t*a = *a ^ *b;\r\n\t*b = *a ^ *b;\r\n\t*a = *a ^ *b;\r\n}\r\n\r\nint main(int argc, char* argv[]) {\r\n\r\n\tint var1 = 22;\r\n\tint var2 = 4;\r\n\tprintf(\"Valores antes da troca: var1=%d var2=%d\\n\", var1, var2);\r\n\tswap(&var1, &var2);\r\n\tprintf(\"Valores depois da troca: var1=%d var2=%d\\n\", var1, var2);\r\n\t\r\n\treturn 0;\r\n}" }, { "path": "other-languages/bitwise/swap_xor/swap_xor.cs", "content": "/*\nAlgoritimo de troca de variveis\nAutor:\n ?\nColaborador:\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\nTipo:\n bitwise\nDescrio:\n Algoritimo que tem objetivo de trocar os valores\n\tde duas variveis sem o uso de uma varivel temporria\n\tusando apenas o operdador boolean \"ou exclusivo\".\n\tLembrando que esse algortimo s funciona se as variveis\n\ttiverem em locais diferentes na memria\nComplexidade:\n O(1)\nDificuldade:\n fcil\nReferncias:\n\thttp://en.wikipedia.org/wiki/XOR_swap_algorithm\n*/\n\nusing System;\n\npublic sealed class SwapXor {\n\n\tpublic static void swap(ref int a, ref int b) {\n\t\n\t\ta = a ^ b;\n\t\tb = a ^ b;\n\t\ta = a ^ b;\n\t}\n\t\n\tpublic static void Main() {\n\t\n\t\tint var1 = 1234;\n\t\tint var2 = 5678;\n\t\t\n\t\tConsole.WriteLine(\"Valores antes da troca: var1 = {0} var2 = {1}\", var1, var2);\n\t\tSwapXor.swap(ref var1, ref var2);\n\t\tConsole.WriteLine(\"Valores depois da troca: var1 = {0} var2 = {1}\", var1, var2);\n\t}\n}" }, { "path": "other-languages/bitwise/swap_xor/swap_xor.php", "content": "\";\r\nswap($var1, $var2);\r\necho \"Valores despois da troca: \\$var1=$var1 \\$var2=$var2
\";\r\n?>" }, { "path": "other-languages/date/leap-year/leap-year.lisp", "content": "#|\nBissexto\nAutor:\n ?\nColaborador\n Daniel Valio \nTipo:\n date\nComplexidade:\n O(1)\nDificuldade:\n Facil\n|#\n\n(defun ano-bissexto-p (&optional (ano (nth-value 5 (get-decoded-time))))\n (and (= (mod ano 4) 0) (or (/= (mod ano 100) 0) (= (mod ano 400) 0))))\n " }, { "path": "other-languages/date/leap-year/leap-year.php", "content": "\nTipo:\n date\nDescrição:\n Calcula os próximos anos bissextos\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Ano_bissexto#Calend.C3.A1rio_Gregoriano\n*/\n\nfunction bissexto($numAnos = 4) {\n $anoAtual = $anoFinal = date('Y');\n $anoFinal += $numAnos;\n \n $anos = array();\n for ($i = $anoAtual; $i <= $anoFinal; $i++) {\n if ($i % 4 == 0 and ($i % 100 or $i % 400 == 0)) {\n $anos[] = $i;\n }\n }\n \n return $anos;\n}\n\n$proxAnosBissexto = bissexto(100);\necho join(', ', $proxAnosBissexto);\n" }, { "path": "other-languages/date/leap-year/leap-year.rb", "content": "=begin\n\nBissexto\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n date\nDescrição:\n Calcula os próximos anos bissextos\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Ano_bissexto#Calend.C3.A1rio_Gregoriano\n\n=end\n\ndef anoBissexto(anos)\n\tanoAtual = Time.now.year\n\tproximoAno = anoAtual + anos\n\tbissextos = []\n\t(anoAtual..proximoAno).each do |ano|\n\t\tif (ano%4 == 0) && (ano % 100 != 0 || ano % 400 == 0)\n\t\t\tbissextos << ano\n\t\tend\n\tend\n\tbissextos\nend\n\nputs anoBissexto(100)\n\n" }, { "path": "other-languages/economics/financiamento/financiamento.cs", "content": "/*\nFinanciamento\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n ?\nDescrição:\n\tCalcula o valor das parcelas do financiamneto\n\tbaseado no capital inicial e taxa de juros\n\tde acordo na função Price\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Tabela_price#C.C3.A1lculo\n*/\n\n\nusing System;\n\nnamespace financiamneto\n{\n\tclass MainClass\n\t{\n\t\tstatic public double financiamneto(double investimento, double juros, int periodo)\n\t\t{\n\t\t\treturn (investimento*juros) / (1 - (1/Math.pow((1+juros),periodo));\n\t\t}\n\t\t\n\t\tpublic static void Main (string[] args)\n\t\t{\n\t\t\tConsole.WriteLine (financiamneto(1000,0.03,4));\n\t\t\tConsole.ReadKey();\n\t\t}\n\t}\n}\n" }, { "path": "other-languages/economics/financiamento/financiamento.lisp", "content": "#|\nFinanciamento\nAutor:\n ?\nColaborador:\n Daniel Valio \nTipo:\n economics\nDescricao:\n Calcula o valor das parcelas do financiamento\n baseado no capital inicial e taxa de juros\n de acordo com a funcao Price\nComplexidade:\n ?\nDificuldade:\n Facil\n|#\n\n(defun valor-parcela (capital juros periodo)\n (/ (* capital juros) (- 1 (/ 1 (expt (1+ juros) periodo)))))" }, { "path": "other-languages/economics/financiamento/financiamento.php", "content": "\nColaborador:\n Felipe Djinn \nTipo:\n econimics\nDescrição:\n\tCalcula o valor das parcelas do financiamneto\n\tbaseado no capital inicial e taxa de juros\n\tde acordo na função Price\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Tabela_price#C.C3.A1lculo\n*/\nfunction financiamento($investimento, $juros, $periodo) {\n return ($investimento * $juros) / (1 - (1 / pow((1 + $juros), $periodo)));\n}\n\necho financiamento(1000, 0.03, 4), \"\\n\";\n" }, { "path": "other-languages/economics/financiamento/financiamento.rb", "content": "# -*- encoding: utf-8 -*-\n\n=begin\nFinanciamento\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n ?\nDescrição:\n\tCalcula o valor das parcelas do financiamneto\n\tbaseado no capital inicial e taxa de juros\n\tde acordo na função Price\nComplexidade:\n ?\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Tabela_price#C.C3.A1lculo\n=end\n\ndef parcelas(investimento, juros, periodo)\n\t(investimento*juros) / (1 - (1/(1+juros)**periodo))\nend\n\t\nputs parcelas(1000, 0.03, 4)\n" }, { "path": "other-languages/economics/juros-compostos/juros-compostos.lisp", "content": "#|\nCalculo de juros compostos\nAutor:\n ?\nColaborador:\n Daniel Valio \nTipo:\n economics\nDescricao:\n Varias formas de se calcular varias modalidades de\n juros compostos.\nComplexidade:\n O(1)\nDificulade:\n Facil\n|#\n\n;;;; Nota: os juros sao colocados em fracoes decimais,\n;;;; e nao porcentagens.\n\n(defun juros-compostos-continuos (capital juros tempo)\n (* capital (exp (* juros tempo))))\n" }, { "path": "other-languages/geography/haversine/haversine.rb", "content": "# -*- encoding: utf-8 -*-\n=begin\nHaversine\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n geography\nDescrição:\n Calcula a distancia mais curta\n entre dois pontos com latitude e longitude\n na superficie da Terra\n usando a formula de haversine\nComplexidade:\n ?\nDificuldade:\n medio\nReferências:\n http://en.wikipedia.org/wiki/Haversine_formula\n\n=end\n\nclass String\t\n\tdef Todegree\n\t grau, minuto, segundo = self.split().collect {|i| i.to_f}\n\t if(self.include? \"-\")\n\t grau -= (minuto/60) + (segundo/3600)\n\t else\n\t grau += (minuto/60) + (segundo/3600)\n end\n\tend\nend\n\nclass Numeric\n\tdef degrees\n\t self * Math::PI / 180.0\n\tend\nend\n\ndef haversin(theta)\n\tMath.sin(theta/2)**2\nend\n\nRadius = 6371 \ndef distancia(latitude1, longitude1, latitude2, longitude2)\n\tdeltaLatitude = (latitude2 - latitude1).degrees\n\tdeltaLongitude = (longitude2 - longitude1).degrees\n\th = haversin(deltaLatitude) + Math.cos(latitude1.degrees)*Math.cos(latitude2.degrees )*haversin(deltaLongitude)\n\t2*Radius*Math.asin(Math.sqrt(h))\nend\n\nputs distancia(\"53 08 50\".Todegree,\"-01 50 58\".Todegree,\"52 12 16\".Todegree,\"00 08 26\".Todegree)\n" }, { "path": "other-languages/graphs/dijkstra/dijkstra.cpp", "content": "/*\nAlgoritmo de Dijkstra (com matriz de adjacências)\nAutores: \n Edsger Dijkstra\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nAlteração:\n\tPéricles Lopes Machado (pericles.raskolnikoff@gmail.com)\nTipo: \n graphs\nDescrição: \n O Algoritmo de Dijsktra é um algoritmo em grafos clássico que determina a\n menor distância de um determinado vértice para todos os outros. Essa é a\n implementação utilizando matriz de adjacências, que tem desempenho \n inferior.\nComplexidade: \n O(|E| log |V|)\nDificuldade: \n medio\nReferências:\n [1] http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm\n [2] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. \n ISBN 978-0-262-53305-8. Páginas 658-659.\n*/\n\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n/*\nParâmetros:\n dist: a matriz de adjacências contendo as distâncias entre os vértices\n*/\n\nconst int n = 5;\nconst int INFINITY = (1 << 30)-1; // 2^30-1\n\n/*\nParâmetros:\n dist: matriz de adjacências que contém as distâncias entre os vértices\n origin: o vértice a partir do qual serão calculadas as menores distâncias\n min_dist: vetor para armazenar as menores distâncias calculadas com o algoritmo\n previous: vetor para armazenar o vértice anterior para chegar ao vértice atual\n (permite determinar as rotas).\n*/\n\nvoid dijkstra(int dist[n][n], int origin, int min_dist[n], int previous[n]) {\n\n // define a lista de adjascencias que é uma representação melhor \n\t// para o algoritmo de Dijkstra. Lembrando que representação é \n\t// uma parte importante na construção de um algoritmo eficiente\n\n\ttypedef vector > Graph;\n\tGraph G(n);\n\n // inicializa (todas as menores distâncias como infinito)\n for (int i = 0; i < n; i++) { \n min_dist[i] = INFINITY;\n previous[i] = -1;\n\n\t\t// cria a lista de adjascências\n\t\tfor (int j = 0; j < n; ++j)\n\t\t\tif (i != j and dist[i][j] < INFINITY) {\n\t\t\t\tG[i].push_back(j);\n\t\t\t}\n }\n \n // exceto a da origem para a origem, que é 0\n min_dist[origin] = 0;\n \n\t// heap utilizada para acelerar a busca pelo melhor opção atual\n\ttypedef pair Pair;\n\tpriority_queue Q;\n\t\n\t// a distancia atual para a origin é utilizada como primeira chave para a ordenação da heap\n\tQ.push(Pair(0, origin));\n\n while (!Q.empty()) {\n\t\tint u = Q.top().second; \n\t\tQ.pop();\n \n for (int i = 0; i < G[u].size(); i++) {\n\t\t\tint v = G[u][i];\n if (min_dist[u] + dist[u][v] < min_dist[i]) {\n min_dist[v] = min_dist[u] + dist[u][v];\n previous[v] = u;\n\n\t\t\t\t// como a priority_queue utiliza a chave de mais alta prioridade para ordenar\n\t\t\t\t// basta multiplar por -1 a estimativa atual para ordenar adequadamente a heap\n\t\t\t\tQ.push(Pair(-min_dist[v], v));\n }\n\t\t}\n }\n}\n\nvoid print_path(int previous[], int n) {\n if ( previous[n] != -1 ) {\n print_path(previous, previous[n]);\n printf(\"-> %d \", n);\n } else \n printf(\"%d \", n);\n}\n\nint main( ) {\n\n // Visualização desse grafo: http://i52.tinypic.com/2qx6z2p.png\n // Distâncias INFINITY indicam que não há aresta que ligue os dois vértices\n int dist[n][n] = {\n {0, 10, INFINITY, 5, INFINITY},\n {INFINITY, 0, 1, 2, INFINITY},\n {INFINITY, INFINITY, 0, INFINITY, 4},\n {INFINITY, 3, 9, 0, 2},\n {2, INFINITY, 6, INFINITY, 0}};\n int min_dist[n], prev[n];\n \n dijkstra(dist, 0, min_dist, prev);\n \n for (int i = 1; i < n; i++) {\n printf(\"Shortest path from 0 to %d: \", i); \n print_path(prev, i);\n printf(\". Distance: %d\\n\", min_dist[i]);\n }\n \n return 0;\n}\n\n" }, { "path": "other-languages/graphs/dijkstra/dijkstra.java", "content": "/*\nAlgoritmo de Dijkstra\nAutor:\n Esdger Dijkstra\nColaborador:\n Filipe Saraiva (filip.saraiva@gmail.com)\nTipo:\n graph\nDescrição:\n O Algoritmo de Dijsktra é um algoritmo em grafos clássico que determina a\n menor distância de um determinado vértice para todos os outros.\nComplexidade:\n O(n²)\nDificuldade:\n medio\nReferências:\n [1] http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm\n [2] http://pt.wikipedia.org/wiki/Algoritmo_de_Dijkstra\n [3] http://www-b2.is.tokushima-u.ac.jp/~ikeda/suuri/dijkstra/Dijkstra.shtml\nLicenca:\n GPLv3\n*/\n\nimport java.util.ArrayList;\n\npublic class dijkstra {\n\t\n\t/**\n\t * Implementação do Algoritmo de Dijkstra\n\t */\n\tpublic static int [][] dijkstra(int [][] matrizSistema){\n\t\t\n\t\t/**\n\t\t * ArrayList para guardar os vértices já verificados pelo Algoritmo de Dijkstra\n\t\t */\n\t\tArrayList verticesVerificados = new ArrayList();\n\t\t\n\t\t/**\n\t\t * ArrayList para guardar as distâncias relativas para cada vértice em cada\n\t\t * iteração do Algoritmo de Dijkstra \n\t\t */\n\t\tArrayList distanciaRelativa = new ArrayList();\n\t\t\n\t\t/**\n\t\t * ArrayList unidimensional que guarda os nós vizinhos de cada nó do grafo\n\t\t * da árvore final produzida pelo Algoritmo de Dijkstra\n\t\t */\n\t\tArrayList nosVizinhos = new ArrayList();\n\t\t\n\t\t/**\n\t\t * Inicialização de variáveis\n\t\t */\n\t\tfor(Integer contador = 0; contador < matrizSistema[0].length; contador++){\n\t\t\tverticesVerificados.add(false);\n\t\t\tnosVizinhos.add(0);\n\t\t\tdistanciaRelativa.add(Integer.MAX_VALUE);\n\t\t}\n\t\t\n\t\tdistanciaRelativa.set(0, new Integer(0));\n\t\t\n\t\t/**\n\t\t * Definição do ponto que será a raiz da árvore resultante\n\t\t */\n\t\tInteger pontoAvaliado = 0;\n\t\t\n\t\t/**\n\t\t * Estrutura para execução das iterações do Algoritmo de Dijkstra\n\t\t */\n\t\tfor(Integer contadorPontosAvaliados = 0; contadorPontosAvaliados < matrizSistema[0].length; contadorPontosAvaliados++){\n\t\t\tfor(Integer contadorVizinhos = 0; contadorVizinhos < matrizSistema[0].length; contadorVizinhos++){\n\n\t\t\t\t/**\n\t\t\t\t * Verifica se o nó a ser avaliado nesta iteração já foi avaliado anteriormente;\n\t\t\t\t * se sim, passa para a próxima iteração\n\t\t\t\t */\n\t\t\t\tif((verticesVerificados.get(contadorVizinhos)) || (contadorVizinhos == pontoAvaliado)){\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t/**\n\t\t\t\t * Duas comparações aqui:\n\t\t\t\t * \n\t\t\t\t * 1ª - Verifica se na matrizSistema há algum valor na coluna que seja > 0. Caso afirmativo,\n\t\t\t\t * significa que há uma aresta entre estes dois pontos do grafo.\n\t\t\t\t * \n\t\t\t\t * 2ª - Verifica se a soma do peso da aresta entre os dois nós mais a distanciaRelativa do nó\n\t\t\t\t * que serve como pontoAvaliado é menor que a atual distanciaRelativa do nó vizinho.\n\t\t\t\t * \n\t\t\t\t * Caso correto, a distanciaRelativa do nó vizinho ao que está sendo avaliado no momento será\n\t\t\t\t * atualizada pelo valor da distanciaRelativa até o pontoAvaliado + distancia entre o pontoAvaliado\n\t\t\t\t * e o nó vizinho.\n\t\t\t\t */\n\t\t\t\t\n\t\t\t\tif((matrizSistema[pontoAvaliado][contadorVizinhos] > 0) &&\n\t\t\t\t\t\t((matrizSistema[pontoAvaliado][contadorVizinhos] + distanciaRelativa.get(pontoAvaliado) < \n\t\t\t\t\t\t\t\tdistanciaRelativa.get(contadorVizinhos)))){\n\t\t\t\t\t\n\t\t\t\t\tdistanciaRelativa.set(contadorVizinhos, matrizSistema[pontoAvaliado][contadorVizinhos] +\n\t\t\t\t\t\t\t distanciaRelativa.get(pontoAvaliado));\n\t\t\t\t\t\n\t\t\t\t\tnosVizinhos.set(contadorVizinhos, pontoAvaliado);\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t/**\n\t\t\t * Marca o vértice de pontoAvaliado como um vértice já verificado\n\t\t\t */\n\t\t\tverticesVerificados.set(pontoAvaliado, true);\n\t\t\t\n\t\t\t/**\n\t\t\t * Preparação para seleção do próximo vértice a ser avaliado\n\t\t\t */\n\t\t\tpontoAvaliado = new Integer(0);\n\t\t\tInteger distanciaComparada = new Integer(Integer.MAX_VALUE);\n\t\t\t\n\t\t\t/**\n\t\t\t * Seleção do próximo vértice a ser avaliado\n\t\t\t */\n\t\t\tfor(Integer contador = 1; contador < verticesVerificados.size(); contador++){\n\t\t\t\t\n\t\t\t\t/**\n\t\t\t\t * Se o vertice a ser verificado já foi verificado anteriormente (true)\n\t\t\t\t * passa à próxima iteração.\n\t\t\t\t */\n\t\t\t\tif(verticesVerificados.get(contador)){\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t/**\n\t\t\t\t * Se a distância relativa desse ponto for menor que a do ponto avaliado\n\t\t\t\t * assume-se esse novo ponto como o ponto avaliado.\n\t\t\t\t * \n\t\t\t\t * Ao final da iteração, será selecionado o ponto com menor\n\t\t\t\t * distância relativa.\n\t\t\t\t */\n\t\t\t\tif(distanciaRelativa.get(contador) < distanciaComparada){\n\t\t\t\t\tdistanciaComparada = distanciaRelativa.get(contador);\n\t\t\t\t\tpontoAvaliado = contador;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\tint [][] matrizResposta = new int [matrizSistema[0].length][matrizSistema[0].length];\n\t\t\n\t\t/**\n\t\t * Criação da matrizResposta com a árvore resultante do Algoritmo de Dijkstra \n\t\t */\n\t\tfor(int contador = 1; contador < nosVizinhos.size(); contador++){\n\t\t\tmatrizResposta[contador][nosVizinhos.get(contador)] = matrizSistema[contador][nosVizinhos.get(contador)];\n\t\t\tmatrizResposta[nosVizinhos.get(contador)][contador] = matrizResposta[contador][nosVizinhos.get(contador)];\n\t\t}\n\t\t\n\t\treturn matrizResposta;\n\t}\n\t\t\n\t/**\n\t * Método main para executar o Algoritmo de Dijkstra\n\t */\n\tpublic static void main(String[] args) {\n\n\t\t/**\n\t\t * Exemplo de grafo - matriz de adjacência onde um número diferente de 0 significa o peso da ligação\n\t\t * entre os nós da matriz\n\t\t * \n\t\t * Você poderá substituir por qualquer matriz quadrada não negativa\n\t\t */\n\t\tint [][] matrizSistema = {{0, 0, 13, 0, 16, 8}, {0, 0, 0, 6, 0, 10}, {13, 0, 0, 14, 0, 11},\n\t\t\t\t{0, 6, 14, 0, 5, 17}, {16, 0, 0, 5, 0, 7}, {8, 10, 11, 17, 7, 0}};\n\t\t\n\t\t/**\n\t\t * Chamada do Algoritmo de Dijkstra\n\t\t */\n\t\tint[][] matrizResultado = dijkstra(matrizSistema);\n\t\t\n\t\t/**\n\t\t * Impressão da matrizResultado com a resposta do Algoritmo de Dijkstra\n\t\t */\n\t\tfor(int contadorHorizontal = 0; contadorHorizontal < matrizResultado[0].length; contadorHorizontal++){\n\t\t\tfor(int contadorVertical = 0; contadorVertical < matrizResultado[0].length; contadorVertical++){\n\t\t\t\t\n\t\t\t\tSystem.out.print(matrizResultado[contadorHorizontal][contadorVertical] + \" \");\n\t\t\t}\n\t\t\t\n\t\t\tSystem.out.println();\n\t\t}\n\t\t\n\t}\n\n}\n" }, { "path": "other-languages/graphs/floyd-warshall/floyd-warshall.cpp", "content": "/*\nAlgoritmo de Floyd-Warshall\nAutores: \n Robert Floyd e Stephen Warshall\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo: \n graphs\nDescrição: \n O Algoritmo de Floyd-Warshall, a partir de uma grafo representado\n em uma matriz (matriz de adjacências), determina as menores distâncias\n entre todos os pares (ou seja, as menores distâncias de todos os \n vértices para todos os vértices).\nComplexidade: \n O(|V|³)\nDificuldade: \n medio\nReferências:\n [1] http://en.wikipedia.org/wiki/Floyd-Warshall\n [2] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. \n ISBN 978-0-262-53305-8. Páginas 693-695.\n*/\n\n#include \n\n/*\nParâmetros:\n dist: a matriz de adjacências contendo as distâncias entre os vértices\n*/\n\nconst int n = 3;\n\nvoid floyd_warshall(int dist[n][n]) {\n for (int k = 0; k < n; k++)\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++) \n if ( dist[i][k] + dist[k][j] < dist[i][j] )\n dist[i][j] = dist[i][k] + dist[k][j];\n}\n\nint main( ) {\n int dist[n][n] = { \n {0, 3, 10},\n {3, 0, 1000},\n {10, 1000, 0}\n };\n\n floyd_warshall(dist);\n \n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n std::cout << \"Menor distancia de \" << i << \" para \" << j << \": \" \n << dist[i][j] << \"\\n\";\n return 0;\n}\n" }, { "path": "other-languages/graphs/prim/prim.java", "content": "/*\nAlgoritmo de Prim\nAutor:\n Vojtěch Jarník(1930) e Robert C. Prim(1957)\nColaborador:\n Filipe Saraiva (filip.saraiva@gmail.com)\nTipo:\n graph\nDescrição:\n O Algoritmo de Prim é um algoritmo em grafos clássico que determina a\n árvore geradora mínima de um grafo conectado não-orientado.\nComplexidade:\n O(n²)\nDificuldade:\n medio\nReferências:\n [1] http://en.wikipedia.org/wiki/Prim%27s_algorithm\n [2] http://pt.wikipedia.org/wiki/Algoritmo_de_Prim\n [3] http://www-b2.is.tokushima-u.ac.jp/~ikeda/suuri/dijkstra/Prim.shtml\nLicenca:\n GPLv3\n*/\n\nimport java.util.ArrayList;\n\npublic class prim {\n\t\n\t/**\n\t * Implementação do Algoritmo de Prim\n\t */\n\tpublic static int [][] prim(int [][] matrizSistema){\n\t\t\n\t\t/**\n\t\t * ArrayList para guardar os vértices já verificados pelo Algoritmo de Prim\n\t\t */\n\t\tArrayList verticesVerificados = new ArrayList();\n\t\t\n\t\t/**\n\t\t * ArrayList para guardar as distâncias relativas para cada vértice em cada\n\t\t * iteração do Algoritmo de Prim\n\t\t */\n\t\tArrayList distanciaRelativa = new ArrayList();\n\t\t\n\t\t/**\n\t\t * ArrayList unidimensional que guarda os nós vizinhos de cada nó do grafo\n\t\t * da árvore final produzida pelo Algoritmo de Prim\n\t\t */\n\t\tArrayList nosVizinhos = new ArrayList();\n\t\t\n\t\t/**\n\t\t * Inicialização de variáveis\n\t\t */\n\t\tfor(Integer contador = 0; contador < matrizSistema[0].length; contador++){\n\t\t\tverticesVerificados.add(false);\n\t\t\tnosVizinhos.add(0);\n\t\t\tdistanciaRelativa.add(Integer.MAX_VALUE);\n\t\t}\n\t\t\n\t\tdistanciaRelativa.set(0, new Integer(0));\n\t\t\n\t\t/**\n\t\t * Definição do ponto que será a raiz da árvore resultante\n\t\t */\n\t\tInteger pontoAvaliado = 0;\n\t\t\n\t\t/**\n\t\t * Estrutura para execução das iterações do Algoritmo de Prim\n\t\t */\n\t\tfor(Integer contadorPontosAvaliados = 0; contadorPontosAvaliados < matrizSistema[0].length; contadorPontosAvaliados++){\n\t\t\tfor(Integer contadorVizinhos = 0; contadorVizinhos < matrizSistema[0].length; contadorVizinhos++){\n\n\t\t\t\t/**\n\t\t\t\t * Verifica se o nó a ser avaliado nesta iteração já foi avaliado anteriormente;\n\t\t\t\t * se sim, passa para a próxima iteração\n\t\t\t\t */\n\t\t\t\tif((verticesVerificados.get(contadorVizinhos)) || (contadorVizinhos == pontoAvaliado)){\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t/**\n\t\t\t\t * Duas comparações aqui:\n\t\t\t\t * \n\t\t\t\t * 1ª - Verifica se na matrizSistema há algum valor na coluna que seja > 0. Caso afirmativo,\n\t\t\t\t * significa que há uma aresta entre estes dois pontos do grafo.\n\t\t\t\t * \n\t\t\t\t * 2ª - Verifica se o peso da aresta entre os dois nós é menor que a atual distanciaRelativa\n\t\t\t\t * do nó vizinho.\n\t\t\t\t * \n\t\t\t\t * Caso correto, a distanciaRelativa do nó vizinho ao que está sendo avaliado no momento será\n\t\t\t\t * atualizada pelo valor dessa nova distancia avaliada até o pontoAvaliado.\n\t\t\t\t */\n\t\t\t\t\n\t\t\t\tif((matrizSistema[pontoAvaliado][contadorVizinhos] > 0) &&\n\t\t\t\t\t\t((matrizSistema[pontoAvaliado][contadorVizinhos] < \n\t\t\t\t\t\t\t\tdistanciaRelativa.get(contadorVizinhos)))){\n\t\t\t\t\t\n\t\t\t\t\tdistanciaRelativa.set(contadorVizinhos, matrizSistema[pontoAvaliado][contadorVizinhos]);\n\t\t\t\t\t\n\t\t\t\t\tnosVizinhos.set(contadorVizinhos, pontoAvaliado);\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t/**\n\t\t\t * Marca o vértice de pontoAvaliado como um vértice já verificado\n\t\t\t */\n\t\t\tverticesVerificados.set(pontoAvaliado, true);\n\t\t\t\n\t\t\t/**\n\t\t\t * Preparação para seleção do próximo vértice a ser avaliado\n\t\t\t */\n\t\t\tpontoAvaliado = new Integer(0);\n\t\t\tInteger distanciaComparada = new Integer(Integer.MAX_VALUE);\n\t\t\t\n\t\t\t/**\n\t\t\t * Seleção do próximo vértice a ser avaliado\n\t\t\t */\n\t\t\tfor(Integer contador = 1; contador < verticesVerificados.size(); contador++){\n\t\t\t\t\n\t\t\t\t/**\n\t\t\t\t * Se o vertice a ser verificado já foi verificado anteriormente (true)\n\t\t\t\t * passa à próxima iteração.\n\t\t\t\t */\n\t\t\t\tif(verticesVerificados.get(contador)){\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t/**\n\t\t\t\t * Se a distância relativa desse ponto for menor que a do ponto avaliado\n\t\t\t\t * assume-se esse novo ponto como o ponto avaliado.\n\t\t\t\t * \n\t\t\t\t * Ao final da iteração, será selecionado o ponto com menor\n\t\t\t\t * distância relativa.\n\t\t\t\t */\n\t\t\t\tif(distanciaRelativa.get(contador) < distanciaComparada){\n\t\t\t\t\tdistanciaComparada = distanciaRelativa.get(contador);\n\t\t\t\t\tpontoAvaliado = contador;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\tint [][] matrizResposta = new int [matrizSistema[0].length][matrizSistema[0].length];\n\t\t\n\t\t/**\n\t\t * Criação da matrizResposta com a árvore resultante do Algoritmo de Prim\n\t\t */\n\t\tfor(int contador = 1; contador < nosVizinhos.size(); contador++){\n\t\t\tmatrizResposta[contador][nosVizinhos.get(contador)] = matrizSistema[contador][nosVizinhos.get(contador)];\n\t\t\tmatrizResposta[nosVizinhos.get(contador)][contador] = matrizResposta[contador][nosVizinhos.get(contador)];\n\t\t}\n\t\t\n\t\treturn matrizResposta;\n\t}\n\t\t\n\t/**\n\t * Método main para executar o Algoritmo de Prim\n\t */\n\tpublic static void main(String[] args) {\n\n\t\t/**\n\t\t * Exemplo de grafo - matriz de adjacência onde um número diferente de 0 significa o peso da ligação\n\t\t * entre os nós da matriz\n\t\t * \n\t\t * Você poderá substituir por qualquer matriz quadrada não negativa\n\t\t */\n\t\tint [][] matrizSistema = {{0, 5, 30, 0, 0, 0}, {5, 0, 20, 10, 0, 0}, {30, 20, 0, 10, 15, 0}, \n\t\t\t\t\t {0, 10, 10, 0, 5, 20}, {0, 0, 15, 5, 0, 15}, {0, 0, 0, 20, 15, 0}};\n\n\t\t/**\n\t\t * Chamada do Algoritmo de Prim\n\t\t */\n\t\tint[][] matrizResultado = prim(matrizSistema);\n\t\t\n\t\t/**\n\t\t * Impressão da matrizResultado com a resposta do Algoritmo de Prim\n\t\t */\n\t\tfor(int contadorHorizontal = 0; contadorHorizontal < matrizResultado[0].length; contadorHorizontal++){\n\t\t\tfor(int contadorVertical = 0; contadorVertical < matrizResultado[0].length; contadorVertical++){\n\t\t\t\t\n\t\t\t\tSystem.out.print(matrizResultado[contadorHorizontal][contadorVertical] + \" \");\n\t\t\t}\n\t\t\t\n\t\t\tSystem.out.println();\n\t\t}\n\t\t\n\t}\n\n}\n" }, { "path": "other-languages/lang/nums2words.c", "content": "/*\nnums2words\nAutor:\n ? \nColaborador:\n Stanislaw Pusep \nTipo:\n lang\nDescrio:\n Conversor de nmeros inteiros em strings de numerais cardinais em portugus.\n Exemplo:\n 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\"\nComplexidade:\n ?\nDificuldade:\n medio\nReferncias: \n [1] http://sysd.org/stas/node/20\n [2] http://pt.wikipedia.org/wiki/Nomes_dos_n%C3%BAmeros\n [3] http://pt.wikipedia.org/wiki/Escalas_curta_e_longa\n*/\n\n#include \n#include \n#include \n\n// tamanhos dos buffers\n#define MAXRES_S\t\t512\n#define MAXTERN_S\t\t64\n\n// formato da estrutura da tabela de transio\ntypedef struct {\n unsigned int n;\n char *w;\n} node;\n\n/*\n * Expande blocos de milhares.\n * Os nmeros maiores do que mil so \"quebrados\" em ternas que depois recebem um multiplicador.\n */\nchar *ext999 (unsigned int n) {\n unsigned int i, x, y;\n char *buf;\n // mapeamento nmero => nome\n node rel[] = {\n {900,\t\"novecentos\"},\t{800,\t\"oitocentos\"},\n {700,\t\"setecentos\"},\t{600,\t\"seiscentos\"},\n {500,\t\"quinhentos\"},\t{400,\t\"quatrocentos\"},\n {300,\t\"trezentos\"},\t{200,\t\"duzentos\"},\n {100,\t\"cento\"},\t {90,\t\"noventa\"},\n {80,\t\"oitenta\"},\t {70,\t\"setenta\"},\n {60,\t\"sessenta\"},\t{50,\t\"cinquenta\"},\n {40,\t\"quarenta\"},\t{30,\t\"trinta\"},\n {20,\t\"vinte\"},\t {19,\t\"dezenove\"},\n {18,\t\"dezoito\"},\t {17,\t\"dezessete\"},\n {16,\t\"dezesseis\"},\t{15,\t\"quinze\"},\n {14,\t\"quatorze\"},\t{13,\t\"treze\"},\n {12,\t\"doze\"},\t {11,\t\"onze\"},\n {10,\t\"dez\"},\t\t {9,\t \"nove\"},\n {8,\t \"oito\"},\t {7,\t \"sete\"},\n {6,\t \"seis\"},\t {5,\t \"cinco\"},\n {4,\t \"quatro\"},\t {3,\t \"trs\"},\n {2,\t \"dois\"},\t {1,\t \"um\"},\n };\n\n buf = (char *) malloc(MAXTERN_S);\n buf[0] = '\\0';\n\n // casos especiais\n if (!n) {\n strcpy(buf, \"zero\");\n return buf;\n } else if (n == 100) {\n strcpy(buf, \"cem\");\n return buf;\n }\n\n // faz a reduo do nmero fatorando pelos ndices do mapeamento\n while (n) {\n for (i = 0; i < sizeof(rel); i++) {\n x = rel[i].n;\n y = n % x;\n if (x + y == n) {\n n = y;\n strcat(buf, rel[i].w);\n if (n)\n strcat(buf, \" e \");\n break;\n }\n }\n }\n\n return buf;\n}\n\nchar *nums2words (long n) {\n unsigned long x;\n unsigned int y;\n\n int i, j, k;\n char *res, *p;\n\n // mapeamento dos multiplicadores para inteiros 'signed' de 64 bits\n char *ord[] = {\n NULL,\t\t NULL,\n \"mil\",\t\t \"mil\",\n \"milho\", \t \"milhes\",\n \"bilho\",\t \"bilhes\",\n \t\"trilho\",\t \"trilhes\",\n \t\"quatrilho\",\t\"quatrilhes\",\n \"quinqualho\", \"quinqualhes\",\n };\n // array para armazenamento das ternas pr-processadas\n unsigned int tern[(sizeof(ord) / sizeof(char *)) / 2];\n\n res = (char *) malloc(MAXRES_S);\n res[0] = '\\0';\n\n // trata nmeros negativos\n if (n < 0) {\n n *= -1;\n strcat(res, \"menos \");\n }\n\n if (n < 1000) {\n // nmeros menores do que mil: caso mais simples\n strcat(res, ext999(n));\n } else {\n // quebra o nmero em ternas\n x = n;\n for (j = 0; x; j++) {\n y = x % 1000;\n x /= 1000;\n\n tern[j] = y;\n }\n\n // obtm string para cada terna e concatenta no resultado\n for (i = j - 1; i >= 0; i--) {\n if (y = tern[i]) {\n // concatena a respectiva terna\n p = ext999(y);\n strcat(res, p);\n free(p);\n\n // trata singular ou plural do multiplicador\n k = i * 2;\n if (y != 1)\n k++;\n\n // concatena o multiplicador\n if (p = ord[k]) {\n strcat(res, \" \");\n strcat(res, p);\n }\n\n // nem sempre o 'e' necessrio; porm desconheo a regra correta :(\n strcat(res, \" e \");\n }\n }\n res[strlen(res) - 3] = '\\0';\n }\n\n return res;\n}\n\n\nint main (void) {\n long n;\n char *p;\n\n do {\n printf(\"Digite um nmero (0 para sair): \");\n scanf(\"%ld\", &n);\n fflush(stdin);\n\n p = nums2words(n);\n printf(\"voc digitou \\\"%s\\\"\\n\", p);\n free(p);\n } while (n);\n\n return 0;\n}\n" }, { "path": "other-languages/math/bhaskara/bhaskara.lisp", "content": "#|\nFormula de Bhaskara \nAutor:\n Bhaskara Akaria\nColaborador:\n Daniel Valio\nTipo:\n math\nDescricao:\n Calcula as raizes de uma equacao de segundo grau \nComplexidade:\n O(1)\nDificuldade:\n facil\n|#\n\n(defun delta-calc (a b c)\n (- (expt b 2) (* a c 4)))\n(defun achar-raizes (a b delta)\n (list (/ (- delta b) (* a 2))\n\t(/ (- (+ delta b)) (* a 2))))\n(defun bhaskara (a b c)\n (unless (< (delta-calc a b c) 0)\n (achar-raizes a b (delta-calc a b c))))\n" }, { "path": "other-languages/math/bhaskara/bhaskara.php", "content": "\n" }, { "path": "other-languages/math/bhaskara/bhaskara.rb", "content": "# encoding: utf-8\n\n=begin\nBhaskara\nAutor:\n Bhaskara Akaria [1]\nColaborador:\n\tBruno Lara Tavares \n Karlisson Bezerra\nTipo:\n math\nDescrição:\n Calcula as raízes de uma equação de segundo grau\nComplexidade: \n O(1)\nDIficuldade:\n facil\nReferências:\n [1] http://pt.wikipedia.org/wiki/Bhaskara_Akaria\n=end\n\ndef bhaskara(a, b, c)\n delta = b ** 2 - 4 * a * c\n if delta < 0\n nil\n else\n raizes = []\n m1 = Math.sqrt delta\n r1 =(-b + m1) / (2 * a)\n raizes.push r1\n r2 =(-b - m1) / (2 * a)\n raizes.push r2\n end\nend\nputs bhaskara 1, -1, -2\n" }, { "path": "other-languages/math/dda/dda.cpp", "content": "/*\nDDA (Digital Differential Analyzer)\nAutor:\n ?\nColaborador:\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\nTipo:\n\tmath\nDescrio:\n DDA um algoritmo de interpolao linear entre dois pontos, inicial e final.\n\tEle muito usado na rea de Computao Grfica para rasterizar linhas e polgonos.\nComplexidade: \n O(n)\nDificuldade:\n facil\nReferncias:\n http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf\n\thttp://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm)\n*/\n\n#include \n#include \n#include \n#include \n\ntypedef struct Point {\n\n\tpublic:\n\t\n\t\tint x;\n\t\tint y;\n\t\t\n\t\tPoint(int x, int y) {\n\t\t\t\n\t\t\tthis->x = x;\n\t\t\tthis->y = y;\n\t\t}\n\t\n} Point;\n\nclass DDA {\n\n\tpublic:\n\t\t\n\t\tstatic std::list& rasteriza(const Point ini, const Point fim) {\n\t\t\n\t\t\tstd::list* points = new std::list(); //Guardara os pontos criados\n\t\t\tfloat len;\n\t\t\n\t\t\tif (abs(fim.x - ini.x) >= abs(fim.y - ini.y)) {\n\t\t\t\t\n\t\t\t\tlen = abs(fim.x - ini.x);\n\t\t\t} else {\n\t\t\t\t\n\t\t\t\tlen = abs(fim.y - ini.y);\n\t\t\t}\n\t\t\t\n\t\t\tfloat deltax = (fim.x - ini.x) / len;\n\t\t\tfloat deltay = (fim.y - ini.y) / len;\n\t\t\tfloat x = ini.x;\n\t\t\tfloat y = ini.y;\n\t\t\t\n\t\t\tfor (int i = 0; i < len; i++) {\n\t\t\t\n\t\t\t\tpoints->push_back(Point((int) floor(x), (int) floor(y)));\n\t\t\t\tx += deltax;\n\t\t\t\ty += deltay;\n\t\t\t}\n\t\t\t\n\t\t\tpoints->push_back(Point((int) floor(x), (int) floor(y)));\n\t\t\t\n\t\t\treturn *points;\n\t\t}\n\t\t\n\tprivate:\n\t\n\t\tDDA() {}\n\t\t~DDA() {}\n};\n\nusing namespace std;\nint main(int argc, char* argv[]) {\n\n\tlist points = DDA::rasteriza(Point(-2, 3), Point(10, 15));\n\tlist::iterator it;\n\t\n\tfor (it = points.begin(); it != points.end(); it++) {\n\t\n\t\tcout << \"(\" << it->x << \", \" << it->y << \")\" << endl;\n\t}\n\t\n\treturn 0;\n}\n" }, { "path": "other-languages/math/dda/dda.cs", "content": "/*\nDDA (Digital Differential Analyzer)\nAutor:\n ?\nColaborador:\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\nTipo:\n\tmath\nDescrio:\n DDA um algoritmo de interpolao linear entre dois pontos, inicial e final.\n\tEle muito usado na rea de Computao Grfica para rasterizar linhas e polgonos.\nComplexidade: \n O(n)\nDificuldade:\n facil\nReferncias:\n http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf\n\thttp://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm)\n*/\nusing System;\nusing System.Collections.Generic;\n\npublic struct Point {\n\n\tpublic int x;\n\tpublic int y;\n\t\n\tpublic Point(int x, int y) {\n\t\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t}\n}\n\npublic static class DDA {\n\n\tpublic static Point[] rasteriza(Point ini, Point fim) {\n\t\n\t\tLinkedList points = new LinkedList(); //Guardara os pontos criados\n\t\tfloat len;\n\t\n\t\tif (Math.Abs(fim.x - ini.x) >= Math.Abs(fim.y - ini.y)) {\n\t\t\t\n\t\t\tlen = Math.Abs(fim.x - ini.x);\n\t\t} else {\n\t\t\t\n\t\t\tlen = Math.Abs(fim.y - ini.y);\n\t\t}\n\t\t\n\t\tfloat deltax = (fim.x - ini.x) / len;\n\t\tfloat deltay = (fim.y - ini.y) / len;\n\t\tfloat x = ini.x;\n\t\tfloat y = ini.y;\n\t\t\n\t\tfor (int i = 0; i < len; i++) {\n\t\t\n\t\t\tpoints.AddLast(new Point((int) Math.Floor(x), (int) Math.Floor(y)));\n\t\t\tx += deltax;\n\t\t\ty += deltay;\n\t\t}\n\t\t\n\t\tpoints.AddLast(new Point((int) Math.Floor(x), (int) Math.Floor(y)));\n\t\t\n\t\tPoint[] ret = new Point[points.Count];\n\t\tpoints.CopyTo(ret, 0);\n\t\t\n\t\treturn ret;\n\t}\n}\n\npublic class MainDDA {\n\n\tpublic static void Main() {\n\t\n\t\tPoint[] points = DDA.rasteriza(new Point(-2, 3), new Point(10, 15));\n\t\tforeach (Point point in points) {\n\t\t\n\t\t\tConsole.WriteLine(\"({0}, {1})\", point.x, point.y);\n\t\t}\n\t}\n}" }, { "path": "other-languages/math/dda/dda.java", "content": "/*\nDDA (Digital Differential Analyzer)\nAutor:\n ?\nColaborador:\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\nTipo:\n\tmath\nDescrio:\n DDA um algoritmo de interpolao linear entre dois pontos, inicial e final.\n\tEle muito usado na rea de Computao Grfica para rasterizar linhas e polgonos.\nComplexidade: \n O(n)\nDificuldade:\n facil\nReferncias:\n http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf\n\thttp://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm)\n*/\n\nimport java.awt.Point;\nimport java.util.LinkedList;\n\npublic class dda {\n\n\tpublic static Point[] rasteriza(Point ini, Point fim) {\n\t\n\t\tLinkedList points = new LinkedList(); //Guardara os pontos criados\n\t\tfloat len;\n\t\n\t\tif (Math.abs(fim.x - ini.x) >= Math.abs(fim.y - ini.y)) {\n\t\t\t\n\t\t\tlen = Math.abs(fim.x - ini.x);\n\t\t} else {\n\t\t\t\n\t\t\tlen = Math.abs(fim.y - ini.y);\n\t\t}\n\t\t\n\t\tfloat deltax = (fim.x - ini.x) / len;\n\t\tfloat deltay = (fim.y - ini.y) / len;\n\t\tfloat x = ini.x;\n\t\tfloat y = ini.y;\n\t\t\n\t\tfor (int i = 0; i < len; i++) {\n\t\t\n\t\t\tpoints.add(new Point((int) Math.floor(x), (int) Math.floor(y)));\n\t\t\tx += deltax;\n\t\t\ty += deltay;\n\t\t}\n\t\t\n\t\tpoints.add(new Point((int) Math.floor(x), (int) Math.floor(y)));\n\t\t\n\t\treturn points.toArray(new Point[0]);\n\t}\n\t\n\tpublic static void main(String[] args) {\n\t\n\t\tPoint[] points = dda.rasteriza(new Point(-2, 3), new Point(10, 15));\n\t\tfor (Point point : points) {\n\t\t\n\t\t\tSystem.out.printf(\"(%d, %d)\\n\", point.x, point.y);\n\t\t}\n\t}\n\t\n}" }, { "path": "other-languages/math/dda/dda.php", "content": "x = $x;\n\t\t$this->y = $y;\n\t}\n}\n\nclass DDA {\n\n\tpublic static function rasteriza($ini, $fim) {\n\t\n\t\t$points = array();\n\t\t$len;\n\t\n\t\tif (abs($fim->x - $ini->x) >= abs($fim->y - $ini->y)) {\n\t\t\t\n\t\t\t$len = abs($fim->x - $ini->x);\n\t\t} else {\n\t\t\t\n\t\t\t$len = abs($fim->y - $ini->y);\n\t\t}\n\t\t\n\t\t$deltax = ($fim->x - $ini->x) / $len;\n\t\t$deltay = ($fim->y - $ini->y) / $len;\n\t\t$x = $ini->x;\n\t\t$y = $ini->y;\n\t\t\n\t\tfor ($i = 0; $i < $len; $i++) {\n\t\t\n\t\t\t$points[] = new Point(floor($x), floor($y));\n\t\t\t$x += $deltax;\n\t\t\t$y += $deltay;\n\t\t}\n\t\t\n\t\t$points[] = new Point(floor($x), floor($y));\n\t\t\n\t\treturn $points;\n\t}\n}\n\n$points = DDA::rasteriza(new Point(-2, 3), new Point(10, 15));\nforeach ($points as $point) {\n\n\techo \"($point->x, $point->y)
\";\n}\n?>" }, { "path": "other-languages/math/dda/dda.rb", "content": "# -*- encoding: utf-8 -*-\r\n\r\n=begin\r\nDDA (Digital Differential Analyzer)\r\nAutor:\r\n ?\r\nColaborador:\r\n\tBruno Lara Tavares \r\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\r\nTipo:\r\n\tmath\r\nDescrio:\r\n DDA um algoritmo de interpolao linear entre dois pontos, inicial e final.\r\n\tEle muito usado na rea de Computao Grfica para rasterizar linhas e polgonos.\r\nComplexidade: \r\n O(n)\r\nDificuldade:\r\n facil\r\nReferncias:\r\n http://www.dca.fee.unicamp.br/courses/IA725/1s2006/notes/n4.pdf\r\n\thttp://en.wikipedia.org/wiki/Digital_Differential_Analyzer_(graphics_algorithm)\r\n=end\r\n\r\n\r\ndef DDA(x1, y1, x2, y2)\r\n\t\r\n\tpoints = [] #Guardar os pontos criados na forma (x, y)\r\n\t\r\n\tif ((x2 - x1).abs >= (y2 - y1).abs)\r\n\t\t\r\n\t\tlen = (x2 - x1).abs\r\n\telse\r\n\t\t\r\n\t\tlen = (y2 - y1).abs\r\n\tend\r\n\t\t\r\n\tdeltax = (x2 - x1).to_f / len\r\n\tdeltay = (y2 - y1).to_f / len\r\n\tx = x1.to_f\r\n\ty = y1.to_f\r\n\t\r\n\t(0..len).each do |i|\r\n\t\tpoints.push [x.floor, y.floor]\r\n\t\tx += deltax\r\n\t\ty += deltay\r\n\tend\r\n\t\r\n\tpoints.push [x.floor, y.floor]\r\nend\r\n\r\n\t\r\nputs DDA(-1, -1, 12, 9).inspect\r\n" }, { "path": "other-languages/math/determinant/determinant.cpp", "content": "/*\nDeterminante de matriz (utilizando decomposição LU)\nAutor: \n Carl Friedrich Gauss\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo: \n math\nDescrição: \n É o algoritmo que calcula o determinante de uma matriz utilizando a\n decomposição LU como base. Como as matrizes L e U são triangulares, \n o determinante delas são o produto das diagonais. Como o determinante de\n L é sempre 1, o determinante da matriz original A é igual ao determinante\n da matriz U.\nComplexidade: \n O(n³)\nDificuldade: \n medio\nReferências:\n http://en.wikipedia.org/wiki/Lu_decomposition\n http://en.wikipedia.org/wiki/Determinant\n http://mathworld.wolfram.com/LUDecomposition.html\n Cormem, Thomas H. Introduction to Algorithms, 3rd Edition.\n ISBN 978-0-262-53305-8. Página 821\n*/\n\n#include \n#include \n\nconst int n = 4;\n\nvoid lu_decomposition(float A[n][n], float U[n][n]) {\n float _A[n][n], L[n][n];\n int i, j, k;\n\n // copia para evitar modificações na matriz original\n for (i = 0; i < n; i++)\n for (j = 0; j < n; j++)\n _A[i][j] = A[i][j];\n\n // inicializa a matriz U com zeros\n for (i = 0; i < n; i++)\n for (j = 0; j < n; j++)\n U[i][j] = 0;\n \n // inicializa a matriz L com 0s acima da diagonal e 1s na diagonal\n for (i = 0; i < n; i++)\n for (j = 0; j < n; j++)\n if ( i < j )\n L[i][j] = 0;\n else if ( i == j )\n L[i][j] = 1;\n \n for (k = 0; k < n; k++) {\n U[k][k] = _A[k][k];\n \n for (i = k + 1; i < n; i++) {\n L[i][k] = _A[i][k]/U[k][k];\n U[k][i] = _A[k][i];\n }\n \n \n for (i = k + 1; i < n; i++)\n for (j = k + 1; j < n; j++)\n _A[i][j] -= L[i][k]*U[k][j]; \n }\n}\n\nfloat determinant(float A[n][n]) {\n float U[n][n];\n float result = 1.0f;\n \n lu_decomposition(A, U);\n \n for (int i = 0; i < n; i++)\n result *= U[i][i];\n \n return result;\n}\n\nint main( ) {\n float A[n][n] = {\n {2.0, 3.0, 1.0, 5.0},\n {6.0, 13.0, 5.0, 19.0},\n {2.0, 19.0, 10.0, 23.0},\n {4.0, 10.0, 11.0, 31.0}};\n\n printf(\"Determinant: %.2f\", determinant(A));\n\n return 0;\n}\n" }, { "path": "other-languages/math/determinant/determinant.rb", "content": "\n=begin\n Matrix Determinant\nAutor:\n ?\nColaborador:\n José Alberto O. Morais Filho (j.moraisg12@gmail.com)\nTipo:\n math\nDescrição:\n Utiliza a decomposição LU para calcular o determinante da matriz. A decomposição LU gera duas matrizes triangulares,\n de forma que A = L * U -> det(A) = det(L) * det(U).\nComplexidade:\n O(n^3)\nDificuldade:\n médio\nReferências:\n [1] http://en.wikipedia.org/wiki/LU_decomposition\n [2] http://en.wikipedia.org/wiki/Determinant\n=end\n\n# Entrada:\n# a = uma matriz quadrada\n# Saída:\n# o determinante dessa matriz\n\ndef lu_decompose(a)\n\n n = a.length\n\n for i in 0..n-1 do\n for j in 0..n-1 do\n a[i][j] = a[i][j].to_f\n end\n end\n\n u = Array.new(n) {Array.new(n) {0}}\n l = Array.new(n) {Array.new(n) {0}}\n\n for i in 0..n-1 do\n for j in 0..n-1 do\n l[i][i] = 1 if i == j\n end\n end\n\n for k in 0..n-1 do\n\n u[k][k] = a[k][k]\n\n for i in k+1..n-1 do\n l[i][k] = a[i][k] / u[k][k]\n u[k][i] = a[k][i]\n end\n\n for i in k+1..n-1 do\n for j in k+1..n-1 do\n a[i][j] = a[i][j] - l[i][k]*u[k][j]\n end\n end\n\n end\n\n return l, u\n\nend\n\ndef determinant(a)\n\n n = a.length\n l, u = lu_decompose(a)\n \n det = 1\n for i in 0..n-1 do\n det *= u[i][i]\n end\n\n det\n\nend\n\n# Exemplos\na = [[1, 3, 2], [9, 5, 4], [8, 6, 7]]\nb = [[4, 3, 8, 4], [12, 1, 9, 13], [5, 14, 2, 10], [6, 16, 7, 11]]\n\nprint(determinant a)\nputs\nprint(determinant b)\n" }, { "path": "other-languages/math/divisors/divisor.rb", "content": "# * encoding: UTF-8 *\n\n=begin\nDivisors\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nDescricao:\n Mostra os divisores de um número\nComplexidade:\n O(n)\nDificuldade:\n facil\n=end\n\n\nclass Numeric\n def divisores()\n a = []\n (1..self+1).each do |i|\n if self % i == 0\n a.push i\n end\n end\n a\n end\nend\n\nputs 12.divisores.inspect\n" }, { "path": "other-languages/math/eratostenes/eratostenes.java", "content": "/*\nCrivo de Eratóstenes\nAutor:\n Eratóstenes (285-194 a.C.)\nColaborador:\n Filipe Saraiva (filip.saraiva@gmail.com)\nTipo:\n math\nDescrição:\n Dado um número máximo, o Crivo de Eratóstenes encontra todos\n os números primos de 0 até este número máximo. \nComplexidade:\n O(n³)\nDificuldade:\n medio\nReferências:\n [1] http://pt.wikipedia.org/wiki/Crivo_de_Erat%C3%B3stenes\n Licenca:\n GPLv3\n*/\n\nimport java.util.ArrayList;\n\npublic class eratostenes {\n\n\t/**\n\t * Crivo de Eratóstenes recebe a lista de todos os números de 2 até o número máximo,\n\t * e o número máximo a ser verificado \n\t */\n\tpublic static ArrayList eratostenes(ArrayList lista, int numVerificacaoMax){\n\t\t\n\t\t/**\n\t\t * A posição do primeiro número avaliado na lista é a posição 0\n\t\t */\n\t\tint posicaoNumAvaliado = 0;\n\t\tint numAvaliado;\n\t\t\n\t\t/**\n\t\t * Atenção! Aqui é criado um loop infinito proposital.\n\t\t * \n\t\t * O mesmo só será terminado quando a condição dentro dele\n\t\t * for atingida e a instrução *break* for executada. \n\t\t */\n\t\twhile(true){\n\t\t\t\n\t\t\t/**\n\t\t\t * Busca-se a posição do número que será avaliado\n\t\t\t */\n\t\t\twhile(lista.get(posicaoNumAvaliado) == 0){\n\t\t\t\tposicaoNumAvaliado++;\n\t\t\t}\n\t\t\t\n\t\t\t/**\n\t\t\t * Inicialização do número avaliado\n\t\t\t */\n\t\t\tnumAvaliado = lista.get(posicaoNumAvaliado);\n\t\t\t\n\t\t\t/**\n\t\t\t * Verificação dos números múltipos do número avaliado na lista\n\t\t\t * \n\t\t\t * Caso o resto da divisão seja igual a 0, o número é múltiplo\n\t\t\t * Então, o algoritmo substitui o valor do antigo número da lista por 0\n\t\t\t */\n\t\t\tfor(int contador = posicaoNumAvaliado + 1; contador < lista.size(); contador++){\n\n\t\t\t\tif((lista.get(contador) % numAvaliado) == 0){\n\t\t\t\t\tlista.set(contador, 0);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t/**\n\t\t\t * Se o número que acabou de ser avaliado for igual ou maior que\n\t\t\t * o número máximo a ser verificado, então o algoritmo termina sua execução \n\t\t\t */\n\t\t\tif(lista.get(posicaoNumAvaliado) >= numVerificacaoMax){\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t\n\t\t\t/**\n\t\t\t * Caso o algoritmo não tenha terminado sua execução, incrementa-se posicaoNumAvaliado\n\t\t\t * para que na próxima iteração se encontre o próximo número a ser avaliado\n\t\t\t */\n\t\t\tposicaoNumAvaliado++;\n\t\t\t\n\t\t}\n\t\t\n\t\tArrayList listaPrimos = new ArrayList();\n\t\t\n\t\t/**\n\t\t * Esta instrução retira os números 0 da lista e coloca-se apenas os\n\t\t * diferentes de 0 na na listaPrimos. Esta lista é o resultado do Crivo\n\t\t * de Eratóstenes\n\t\t */\n\t\tfor(int contador = 0; contador < lista.size(); contador++){\n\t\t\n\t\t\tif(lista.get(contador) != 0){\n\t\t\t\tlistaPrimos.add(lista.get(contador));\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn listaPrimos;\n\t}\n\t\n\t/**\n * Método main para executar o Crivo de Eratóstenes\n */\n\tpublic static void main(String[] args) {\n\t\t\n\t\t/**\n\t\t * Lista que guardará os números entre 2 e o número limite máximo\n\t\t * do algoritmo\n\t\t */\n\t\tArrayList lista = new ArrayList();\n\t\t\n\t\t/**\n\t\t * Número limite máximo aleatório.\n\t\t * Altere aqui para encontrar todos os números primos\n\t\t * até ele!\n\t\t */\n\t\tint numLimiteMax = 120;\n\t\t\n\t\t/**\n\t\t * O número máximo a ser verificado é o piso da raiz quadrada\n\t\t * do número limite máximo. Esta instrução encontra este número\n\t\t */\n\t\tint numVerificacaoMax = (int) Math.floor(Math.sqrt(numLimiteMax));\n\t\t\n\t\t/**\n\t\t * Instrução para adicionar os números na lista que vai de 2 (o primeiro número primo)\n\t\t * até o número limite máximo escolhido\n\t\t */\n\t\tfor(int contador = 2; contador <= numLimiteMax; contador++){\n\t\t\tlista.add(contador);\n\t\t}\n\t\t\n\t\t/**\n\t\t * Captura do resultado do Crivo de Eratostenes\n\t\t */\n\t\tArrayList listaPrimos = eratostenes(lista, numVerificacaoMax);\n\t\t\n\t\t/**\n\t\t * Impressão do resultado do Crivo de Eratostenes\n\t\t */\n\t\tfor (Integer integer : listaPrimos) {\n\t\t\tSystem.out.print(integer + \" \");\n\t\t}\n\t\tSystem.out.println();\n\t}\n\n}\n" }, { "path": "other-languages/math/even/even.c", "content": "/*\nEncontrando números Pares\nAutor:\n ???\nColaboradores:\n Filipe Saraiva (filip.saraiva@gmail.com)\n Pedro Arthur Duarte (pedroarthur.jedi@gmail.com)\nTipo:\n math\nDescrição:\n Dá-se um número inteiro não negativo; o algoritmo\n listará todos os números pares entre 0 e este número\n dado.\nComplexidade:\n O(n)\nDificuldade:\n fácil\n*/\n\n#include \n\n// Função para imprimir os números pares\n// entre '0' e um número máximo dado.\nvoid numerosPares(int num){\n \n int contador = 0;\n \n /*\n * Maneira convencional: caso o número a ser comparado\n * tiver o resto da divisão igual a '0', quer dizer quer\n * o número é um múltiplo de 2 - definição de número par.\n */\n for(contador = 0; contador <= num; contador++){\n \n if((contador % 2) == 0){\n printf(\"%d \", contador);\n }\n }\n \n /*\n * Maneira esperta - sabemos que o primeiro número par é igual à 0.\n * Daí, basta apenas incrementar o contador em mais duas unidades.\n * Todos os demais números serão pares.\n * \n * Descomente a rotina abaixo para a \"Maneira esperta\".\n */\n// for(contador = 0; contador <= num; contador = contador + 2){\n// printf(\"%d \", contador);\n// }\n \n printf(\"\\n\");\n}\n\n/* Via aritimética binária (maneira convencional) */\nvoid numerosPares_2(int num) {\n int contador;\n \n for (contador = 0 ; contador <= num ; contador++)\n if ((contador & 1) == 0)\n printf(\"%d \", contador);\n}\n\n// Função main\nint main(){\n \n // Número máximo a ser utilizado.\n // Troque-o por outro número qualquer.\n int limite = 13;\n \n // Chamada da função numerosPares\n numerosPares(limite);\n \n return 0;\n}\n" }, { "path": "other-languages/math/fatorial/fatorial.cs", "content": "/*\nCálculo de fatorial\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n math\nDescrição:\n Calcula o fatorial de um número\nComplexidade: \n ?\nDificuldade:\n facil\n*/\n\n\nusing System;\n\nnamespace fatorial\n{\n\tclass MainClass\n\t{\n\t\tstatic public double fatorial(int num)\n\t\t{\n\t\t\treturn num > 1 ?num*fatorial(num-1):1;\n\t\t}\n\t\t\n\t\tpublic static void Main (string[] args)\n\t\t{\n\t\t\tConsole.Write (\"Digite o numero para calcular o fatorial: \");\n\t\t\tConsole.WriteLine (fatorial(int.Parse(Console.ReadLine())));\n\t\t\tConsole.ReadKey();\n\t\t}\n\t}\n}\n" }, { "path": "other-languages/math/fatorial/fatorial.lisp", "content": "#|\nFatorial\nAutor\n ?\nColaborador\n Daniel Valio \nTipo\n math\nDescricao\n Varias formas diferentes de se calcular um \n fatorial em Common Lisp.\nComplexidade\n (?)\nDificuldade\n Facil\n|#\n\n(defun fatorial-basico (n) ;;; Versao basica e recursiva\n (if (<= n 1)\n 1\n (* n (fatorial-basico (- n 1)))))\n(defun fatorial-melhorado (n &optional (acc 1)) ;;; Versao recursiva e (algo) otimizada\n (if (<= n 1)\n acc\n (fatorial-melhorado (- n 1) (* acc n))))\n" }, { "path": "other-languages/math/fatorial/fatorial.php", "content": "\nTipo:\n math\nDescrição:\n Calcula o fatorial de um número\nComplexidade: \n ?\nDificuldade:\n facil\n*/\n\n\nfunction fatorial($b) {\n\treturn $b <= 1 ? 1 : $b*fatorial($b-1);\n}\n\necho fatorial(6);\n\n?>\n" }, { "path": "other-languages/math/fatorial/fatorial.rb", "content": "# -*- encoding: utf-8 -*-\n\n\"\"\"\nCálculo de fatorial\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \nTipo:\n math\nDescrição:\n Calcula o fatorial de um número\nComplexidade: \n ?\nDificuldade:\n facil\n\"\"\"\n\n\ndef fatorial(b)\n\tb <= 1 ? 1 : b*fatorial(b-1)\nend\n\nputs fatorial(6)\n" }, { "path": "other-languages/math/fibonacci/fibonacci.c", "content": "/*\n\tFibonacci recursivo e iterativo\nAutor:\n Fibonacci\nColaborador:\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\nTipo:\n math\nDescrio:\n Algoritmo usado para gerar a sequncia de Fibonacci.\n\tUm termo a soma de seus 2 antecessores. Sendo os primeiros\n\tdois termos com valores 0 e 1 respectivamente.\n\t0, 1, 2, 3, 5, 8, 13, ...\nComplexidade: \n O(n)\nDificuldade:\n facil\n*/\n\n#include \n\nunsigned int fibonacci_recursivo(unsigned int nTermo) {\n\n\tif (nTermo == 1) {\n\t\n\t\treturn 0;\n\t} else if (nTermo == 2) {\n\t\n\t\treturn 1;\n\t}\n\t\n\treturn fibonacci_recursivo(nTermo - 1) + fibonacci_recursivo(nTermo - 2);\n}\n\nunsigned int fibonacci_iterativo(unsigned int nTermo) {\n\n\tunsigned int ante1 = 0; //Antecessor mais longe\n\tunsigned int ante2 = 1; //Antecessor mais perto\n\tint i; //Varivel de controle\n\t\n\tif (nTermo == 1) {\n\t\n\t\treturn 0;\n\t} else if (nTermo == 2) {\n\t\n\t\treturn 1;\n\t}\n\t\n\tfor (i = 3; i <= nTermo; i++) {\n\t\n\t\tunsigned int tmp = ante2;\n\t\tante2 = ante1 + ante2;\n\t\tante1 = tmp;\n\t}\n\t\n\treturn ante2;\n}\n\n//Nmero de termos que sero gerados pelas funes\n#define NTERMOS 22\n\n\nint main(int argc, char* argv[]) {\n\n\tint i;\n\t\n\tfor (i = 1; i <= NTERMOS; i++) {\n\t\n\t\tprintf(\"%d \", fibonacci_recursivo(i));\n\t}\n\t\n\tputchar('\\n');\n\t\n\tfor (i = 1; i <= NTERMOS; i++) {\n\t\n\t\tprintf(\"%d \", fibonacci_iterativo(i));\n\t}\n\t\n\treturn 0;\n}" }, { "path": "other-languages/math/fibonacci/fibonacci.clj", "content": "(comment \nCálculo da sequência de Fibonacci\nAutor \n ? \nColaborador\n Guilherme Victal (guilhermevictal em gmail.com) \nTipo\n math\nDescrição \n Cálculo do n-ésimo valor da sequência de fibonacci recursivamente,\n a partir da definição [a[n]=a[n-1] + a[n-2], a[0]=a[1]=1]\n Na prática é muito lento mesmo para n não muito grande;\nComplexidade\n ? \nDificuldade\n facil\n)\n\n\n(defn fibonacci [n]\n (if (< n 2)\n 1\n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))\n\n\n(println (map fibonacci (range 1 20)))\n\n" }, { "path": "other-languages/math/fibonacci/fibonacci.cs", "content": "/*\r\n\tFibonacci recursivo e iterativo\r\nAutor:\r\n Fibonacci\r\nColaborador:\r\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\r\nTipo:\r\n math\r\nDescrio:\r\n Algoritmo usado para gerar a sequncia de Fibonacci.\r\n\tUm termo a soma de seus 2 antecessores. Sendo os primeiros\r\n\tdois termos com valores 0 e 1 respectivamente.\r\n\t0, 1, 2, 3, 5, 8, 13, ...\r\nComplexidade: \r\n O(n)\r\nDificuldade:\r\n facil\r\n*/\r\n\r\nusing System;\r\n\r\npublic class Fibonacci {\r\n\r\n\tpublic static uint fibonacci_recursivo(uint ntermo) {\r\n\t\r\n\t\tif (ntermo == 0) {\r\n\t\t\r\n\t\t\tthrow new Exception(\"Term position must be greater than 0\");\r\n\t\t} else if (ntermo == 1) {\r\n\t\r\n\t\t\treturn 0;\r\n\t\t} else if (ntermo == 2) {\r\n\t\r\n\t\t\treturn 1;\r\n\t\t}\r\n\t\r\n\t\treturn fibonacci_recursivo(ntermo - 1) + fibonacci_recursivo(ntermo - 2);\r\n\t}\r\n\t\r\n\tpublic static uint fibonacci_iterativo(uint ntermo) {\r\n\t\r\n\t\tif (ntermo == 0) {\r\n\t\t\r\n\t\t\tthrow new Exception(\"Term position must be greater than 0\");\r\n\t\t} else if (ntermo == 1) {\r\n\t\t\r\n\t\t\treturn 0;\r\n\t\t} else if (ntermo == 2) {\r\n\t\t\r\n\t\t\treturn 1;\r\n\t\t}\r\n\t\t\r\n\t\tuint ante1 = 0;\r\n\t\tuint ante2 = 1;\r\n\t\tfor (int i = 3; i <= ntermo; i++) {\r\n\t\t\r\n\t\t\tuint tmp = ante2;\r\n\t\t\tante2 = ante1 + ante2;\r\n\t\t\tante1 = tmp;\r\n\t\t}\r\n\t\t\r\n\t\treturn ante2;\r\n\t}\r\n\t\r\n\tpublic static void Main() {\r\n\t\r\n\t\tfor (uint i = 1; i < 15; i++) {\r\n\t\t\r\n\t\t\tConsole.Write(Fibonacci.fibonacci_recursivo(i) + \" \");\r\n\t\t}\r\n\t\t\r\n\t\tConsole.WriteLine();\r\n\t\t\r\n\t\tfor (uint i = 1; i < 15; i++) {\r\n\t\t\r\n\t\t\tConsole.Write(Fibonacci.fibonacci_iterativo(i) + \" \");\r\n\t\t}\r\n\t}\r\n}" }, { "path": "other-languages/math/fibonacci/fibonacci.java", "content": "/*\n\tFibonacci recursivo e iterativo\nAutor:\n Fibonacci\nColaborador:\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\nTipo:\n math\nDescrio:\n Algoritmo usado para gerar a sequncia de Fibonacci.\n\tUm termo a soma de seus 2 antecessores. Sendo os primeiros\n\tdois termos com valores 0 e 1 respectivamente.\n\t0, 1, 2, 3, 5, 8, 13, ...\nComplexidade: \n O(n)\nDificuldade:\n facil\n*/\n\npublic class fibonacci {\n\n\tpublic static int fibonacci_recursivo(int ntermo) {\n\t\n\t\tif (ntermo < 0) {\n\t\t\n\t\t\tthrow new IllegalArgumentException(\"Term position must be greater than 0\");\n\t\t} else if (ntermo == 1) {\n\t\t\n\t\t\treturn 0;\n\t\t} else if (ntermo == 2) {\n\t\t\n\t\t\treturn 1;\n\t\t}\n\t\t\n\t\treturn fibonacci_recursivo(ntermo - 1) + fibonacci_recursivo(ntermo - 2);\n\t}\n\t\n\tpublic static int fibonacci_iterativo(int ntermo) {\n\t\n\t\tif (ntermo < 0) {\n\t\t\n\t\t\tthrow new IllegalArgumentException(\"Term position must be greater than 0\");\n\t\t} else if (ntermo == 1) {\n\t\t\n\t\t\treturn 0;\n\t\t} else if (ntermo == 2) {\n\t\t\n\t\t\treturn 1;\n\t\t}\n\t\t\n\t\tint ante1 = 0;\n\t\tint ante2 = 1;\n\t\tfor (int i = 3; i <= ntermo; i++) {\n\t\t\n\t\t\tint tmp = ante2;\n\t\t\tante2 = ante1 + ante2;\n\t\t\tante1 = tmp;\n\t\t}\n\t\t\n\t\treturn ante2;\n\t}\n\t\n\tpublic static void main(String[] args) {\n\t\n\t\tfor (int i = 1; i < 15; i++) {\n\t\t\n\t\t\tSystem.out.print(fibonacci.fibonacci_recursivo(i) + \" \");\n\t\t}\n\t\t\n\t\tSystem.out.println();\n\t\t\n\t\tfor (int i = 1; i < 15; i++) {\n\t\t\n\t\t\tSystem.out.print(fibonacci.fibonacci_iterativo(i) + \" \");\n\t\t}\n\t}\n}" }, { "path": "other-languages/math/fibonacci/fibonacci.lisp", "content": "#|\nCalculo da sequencia de Fibonacci\nAutor\n ?\nColaborador\n Daniel Valio \nTipo\n math\nDescricao\n Calculo de Fn aonde F e' a sequencia de Fibonacci.\n Note-se que, apesar de ser quase o mesmo co'digo\n da versao em Clojure, esta e' muito mais ra'pida,\n pois em Common Lisp ha' TCO (Tail Call Optimization).\nComplexidade\n ?\nDificuldade\n Facil\n|#\n\n(defun fibonacci (n)\n (if (< n 2)\n 1\n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))\n" }, { "path": "other-languages/math/fibonacci/fibonacci.lua", "content": "--[[\n\tFibonacci recursivo e iterativo\nAutor:\n Fibonacci\nColaborador:\n Jos Ivan Bezerra Vilarouca Filho (ivanfilho2204@hotmail.com)\nTipo:\n math\nDescrio:\n Algoritmo usado para gerar a sequncia de Fibonacci.\n\tUm termo a soma de seus 2 antecessores. Sendo os primeiros\n\tdois termos com valores 0 e 1 respectivamente.\n\t0, 1, 2, 3, 5, 8, 13, ...\nComplexidade: \n O(n)\nDificuldade:\n facil\n]]--\n\nfunction fibonacci_recursivo(ntermos)\n\n\tif (ntermos < 1) then\n\t\n\t\treturn;\n\telseif (ntermos == 1) then\n\t\n\t\treturn 0;\n\telseif (ntermos == 2) then\n\t\n\t\treturn 1;\n\tend\n\t\n\treturn fibonacci_recursivo(ntermos - 1) + fibonacci_recursivo(ntermos - 2);\nend\n\nfunction fibonacci_iterativo(ntermos)\n\n\tif (ntermos < 1) then\n\t\n\t\treturn;\n\telseif (ntermos == 1) then\n\t\n\t\treturn 0;\n\telseif (ntermos == 2) then\n\t\n\t\treturn 1;\n\tend\n\t\n\tlocal ante1, ante2, i = 0, 1, 3;\n\twhile (i <= ntermos) do\n\t\n\t\tante1, ante2 = ante2, ante1 + ante2;\n\t\ti = i + 1;\n\tend\n\t\n\treturn ante2;\nend\n\nj = 1;\nwhile (j <= 15) do\n\n\tio.write(fibonacci_recursivo(j) .. \" \");\n\tj = j + 1;\nend\n\nprint(\"\");\n\nj = 1;\nwhile (j <= 15) do\n\n\tio.write(fibonacci_iterativo(j) .. \" \");\n\tj = j + 1;\nend\n" }, { "path": "other-languages/math/fibonacci/fibonacci.php", "content": "\n * Tipo:\n * math\n * Descrição:\n * Na matemática, os Números de Fibonacci são uma sequência definida como recursiva.\n * O algoritmo recursivo que define a série aplica-se, na prática, conforme a regra sugere: \n * começa-se a série com 0 e 1; a seguir, obtém-se o próximo número de Fibonacci somando-se \n * os dois anteriores e, assim, sucessiva e infinitamente.\n * Complexidade:\n * F(n) = {\n * 0 se n = 0;\n * 1 se n = 1;\n * F(n - 1) + F(n - 2)\n * }\n * Referências:\n * http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci\n */\nfunction fibonacci($n) {\n if ( $n < 2 ) return $n;\n\n return fibonacci($n - 1) + fibonacci($n - 2);\n}\n\n// example\nfor ( $i = 0; $i <= 20; $i++ ) {\n echo fibonacci($i), ' ';\n}\n\necho \"\\n\";\n" }, { "path": "other-languages/math/fibonacci/fibonacci.rb", "content": "# -*- encoding: utf-8 -*-\n=begin\n * Sequência de Fibonacci\n *\n * Autor:\n * Felipe Djinn \n * Colaborador:\n * Bruno Lara Tavares \n * Tipo:\n * math\n * Descrição:\n * Na matemática, os Números de Fibonacci são uma sequência definida como recursiva.\n * O algoritmo recursivo que define a série aplica-se, na prática, conforme a regra sugere: \n * começa-se a série com 0 e 1; a seguir, obtém-se o próximo número de Fibonacci somando-se \n * os dois anteriores e, assim, sucessiva e infinitamente.\n * Complexidade:\n * F(n) = {\n * 0 se n = 0;\n * 1 se n = 1;\n * F(n - 1) + F(n - 2)\n * }\n * Referências:\n * http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci\n *\n=end\nclass Numeric\n\tdef fibonacci\n\t\tif (self < 2)\n\t\t\tself\n\t\telse\n\t\t\t(self - 1).fibonacci + (self -2).fibonacci\n\t\tend\n\tend\nend\n\n(0..20).each do |nesimo|\n\tputs nesimo.fibonacci\nend\n" }, { "path": "other-languages/math/gauss/sumgauss.cpp", "content": "/*\n Soma de Gauus - Gauss Sum\nAutores: \n\tCarl Friedrich Gauss \nColaborador:\n Kaio Turubia (kaiokot@gmail.com)\nTipo: \n math\nDescrição: \n É um algoritmo que, dado um número, é a realizada a soma de 1 até o número informado.\n\tEx: Soma de 1 a 100:\n\tS = 1+2+3+...+99+100 = 5050\n\tEx: Soma de 1 a 100:\n\tS = 1+2+3+...+99+100 = 5050\nComplexidade: \n ?\nDificuldade: \n facil\nReferências:\n [1] http://pt.wikipedia.org/wiki/Soma_de_Gauss\n\n*/\n#include \n\nint gaussSum(int number)\n{\n int result;\n result = number * (number + 1) / 2;\n return (result);\n}\n\nint main ()\n{ \n\tint number = 100;\n\tint result; \n\tresult = gaussSum(number);\n\tstd::cout << \"The sum value is : \" << result;\n\treturn 0;\n}\n" }, { "path": "other-languages/math/geometric-mean/geometric-mean.cpp", "content": "/*\nMédia geométrica\nAutor: \n ?\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo:\n math\nDescrição: \n É um algoritmo simples para calcular a média geométrica de n números\n reais utilizando o método de média de logaritmos (que é mais numericamente\n estável e computacionalmente mais eficiente que multiplicar\n todos os números e tirar a raiz, além de evitar o problema de overflow).\nComplexidade de tempo: \n O(n)\nDificuldade: \n facil\nReferências:\n http://en.wikipedia.org/wiki/Geometric_mean\n http://en.wikipedia.org/wiki/Numeric_stability\n*/\n\n#include \n#include \n\ndouble geometric_mean(double values[], int n) {\n double sum = 0.0;\n \n for (int i = 0; i < n; i++)\n sum += log(values[i]);\n \n sum /= n;\n return exp(sum);\n}\n\nint main( ) {\n double values[] = {1, 2, 3, 4, 5};\n printf(\"%.10f\\n\", geometric_mean(values, 5));\n return 0;\n}\n" }, { "path": "other-languages/math/linear-system/linear-system.c", "content": "/*\nAlgoritmo para Escalonar Sistemas Lineares\nAutor:\n ?\nColaborador:\n ?\nTipo:\n math\nDescrição:\n Esta função recebe uma matriz m, n por n, e uma\n matriz R n por 1.\n Ela escalona o sistema mX = R, e atribui a R as\n soluções do sistema.\n Retorna 1, caso tenha sucesso no escalonamento,\n ou 0 caso contrário.\nComplexidade:\n O(n^2), sendo n a dimensão do sistema.\nDificuldade:\n medio\n*/\n\nint escalonaSistemaLinear(double **m, int n, double R[]){\n int i, j, k;\n for(i=0;i=i;k--){\n m[i][k]/=m[i][i];\n for(j=0;j\n#include \n\nconst int n = 4;\n\nvoid lu_decomposition(float A[n][n], float L[n][n], float U[n][n]) {\n float _A[n][n];\n int i, j, k;\n\n // copia para evitar modificações na matriz original\n for (i = 0; i < n; i++)\n for (j = 0; j < n; j++)\n _A[i][j] = A[i][j];\n\n // inicializa a matriz U com zeros\n for (i = 0; i < n; i++)\n for (j = 0; j < n; j++)\n U[i][j] = 0;\n \n // inicializa a matriz L com 0s acima da diagonal e 1s na diagonal\n for (i = 0; i < n; i++)\n for (j = 0; j < n; j++)\n if ( i < j )\n L[i][j] = 0;\n else if ( i == j )\n L[i][j] = 1;\n \n for (k = 0; k < n; k++) {\n U[k][k] = _A[k][k];\n \n for (i = k + 1; i < n; i++) {\n L[i][k] = _A[i][k]/U[k][k];\n U[k][i] = _A[k][i];\n }\n \n \n for (i = k + 1; i < n; i++)\n for (j = k + 1; j < n; j++)\n _A[i][j] -= L[i][k]*U[k][j]; \n }\n}\n\nint main( ) {\n float A[n][n] = {\n {2.0, 3.0, 1.0, 5.0},\n {6.0, 13.0, 5.0, 19.0},\n {2.0, 19.0, 10.0, 23.0},\n {4.0, 10.0, 11.0, 31.0}};\n float L[n][n], U[n][n];\n int i, j;\n \n lu_decomposition(A, L, U);\n \n for (i = 0; i < n; i++) { \n printf(\"[ \");\n \n for (j = 0; j < n; j++)\n printf(\"%.2f \", L[i][j]);\n \n printf(\"] [ \");\n \n for (j = 0; j < n; j++)\n printf(\"%.2f \", U[i][j]);\n \n printf(\"]\\n\");\n }\n\n return 0;\n}\n" }, { "path": "other-languages/math/lu-decomposition/lu-decomposition.rb", "content": "\n=begin\n LU Decomposition\nAutor:\n ?\nColaborador:\n José Alberto O. Morais Filho (j.moraisg12@gmail.com)\nTipo:\n math\nDescrição:\n Fatora uma matriz não singular em duas matrizes triangulares, uma superior (upper) e uma inferior (lower). É\n utilizado para facilitar resoluções de sistemas de equações lineares ou o cálculo de determinates.\nComplexidade:\n O(n^3)\nDificuldade:\n medio\nReferências:\n [1] http://en.wikipedia.org/wiki/LU_decomposition\n [2] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 819-822)\n=end\n\n# Entrada:\n# a = array a ser fatorado\n# Saída:\n# dois arrays, l e u\n\ndef lu_decompose(a)\n\n n = a.length\n\n for i in 0..n-1 do\n for j in 0..n-1 do\n a[i][j] = a[i][j].to_f\n end\n end\n\n u = Array.new(n) {Array.new(n) {0}}\n l = Array.new(n) {Array.new(n) {0}}\n\n for i in 0..n-1 do\n for j in 0..n-1 do\n l[i][i] = 1 if i == j\n end\n end\n\n for k in 0..n-1 do\n\n u[k][k] = a[k][k]\n\n for i in k+1..n-1 do\n l[i][k] = a[i][k] / u[k][k]\n u[k][i] = a[k][i]\n end\n\n for i in k+1..n-1 do\n for j in k+1..n-1 do\n a[i][j] = a[i][j] - l[i][k]*u[k][j]\n end\n end\n \n end\n\n return l, u\n\nend\n\n# Exemplos\na = [[1, 3, 2], [9, 5, 4], [8, 6, 7]]\nl, u = lu_decompose(a)\nprint \"L: #{l}, U: #{u}\"\n\nputs\n\nb = [[4, 3, 8, 4], [12, 1, 9, 13], [5, 14, 2, 10], [6, 16, 7, 11]]\nl, u = lu_decompose(b)\nprint \"L: #{l}, U: #{u}\"\n\n" }, { "path": "other-languages/math/matrix-transpose/matrix-transpose.cpp", "content": "/*\nTransposição de matrizes\nAutor: \n ?\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo:\n math\nDescrição: \n Calcula a matriz tranposta de uma matriz qualquer, ou seja, a matriz\n resultante da troca das linhas pelas colunas.\nComplexidade de tempo: \n O(m*n)\nDificuldade: \n facil\nReferências:\n http://en.wikipedia.org/wiki/Transpose\n*/\n\n#include \n\nconst int m = 3;\nconst int n = 4;\n\ndouble transpose(int a[m][n], int b[n][m]) {\n for (int i = 0; i < m; i++)\n for (int j = 0; j < n; j++)\n b[j][i] = a[i][j];\n}\n\nint main( ) {\n int a[m][n] = {\n {1, 2, 3, 4},\n {5, 6, 7, 8},\n {9, 10, 11, 12}};\n int b[n][m];\n int i, j;\n \n transpose(a, b);\n \n for (i = 0; i < n; i++) {\n for (j = 0; j < m; j++) \n std::cout << b[i][j] << \" \"; \n std::cout << \"\\n\";\n }\n\n return 0;\n}\n" }, { "path": "other-languages/math/media/media.lisp", "content": "#|\nCalculo de media ponderada\nAutor:\n ?\nColaborador:\n Daniel Valio \nTipo:\n math\nDescricao:\n Calcula a media ponderada entre tres numeros.\nComplexidade:\n O(1)\nDificuldade:\n facil\n|#\n\n(defun media (a b c &optional (peso-a 1) (peso-b 1) (peso-c 1))\n (/ (+ (* a peso-a) (* b peso-b) (* c peso-c)) \n (+ peso-a peso-b peso-c)))\n" }, { "path": "other-languages/math/media/media.php", "content": "" }, { "path": "other-languages/math/media/media.rb", "content": "# encoding: utf-8\n\n=begin\nCálculo da média ponderada\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \n Karlisson Bezerra\nTipo:\n math\nDescrição:\n Calcula a média ponderada - é um algoritmo\n comum em qualquer curso de introdução à programação,\n que pode variar de acordo com os pesos.\nComplexidade: \n O(1)\nDificuldade:\n facil\n=end\n\n\ndef media(n1, n2, n3)\n p1, p2, p3 = 4, 5, 6\n (n1 * p1 + n2 * p2 + n3 * p3).to_f / (p1 + p2 + p3)\nend\n\nputs media(7.0, 8.0, 10.0)\n" }, { "path": "other-languages/math/media-num/media-num.c", "content": "/*\nMedia\nAutor:\n ?\nColaborador:\n Guilherme Carlos (@guiessence)\nTipo:\n math\nDescrição:\n Calcula a média de numeros inseridos pelo usuário\nComplexidade: \n 0(1)\nDificuldade:\n facil\n<<<<<<< HEAD\n=======\n\n>>>>>>> 9bb9c79831232255550163f21f9098b8060bfae3\n*/\n\n#include \n#include \n\nvoid main(){\n float media, num;\n int qtd, i, cont = 0;\n\n printf(\"Digite a quantidade de numeros:\\n\");\n scanf(\"%d\", &qtd);\n\n for(i = 0; i < qtd; i++){\n printf(\"Digite um numero:\\n\");\n scanf(\"%f\", &num);\n media = media + num;\n cont++;\n }\n\n media = media/cont;\n printf(\"Media: %.2f: \\n\",media);\n}\n" }, { "path": "other-languages/math/media-num/media-num.rb", "content": "# -*- encoding: utf-8 -*-\n\n=begin\nMedia Numerica\nAutor:\n ?\nColaborador:\n\tBruno Lara Tavares \n Guilherme Carlos (@guiessence)\nTipo:\n math\nDescrição:\n Calcula a média de numeros inseridos pelo usuário\nComplexidade: \n 0(1)\nDificuldade:\n facil\n=end\n\ndef media(*args)\n\tsum = 0\n\targs.each do |i|\n\t\tsum += i\n\tend\n\tsum.to_f / args.size\nend\n\n#Adicione a quantidade de numeros que for preciso\nputs media(2,3,4,10)\n" }, { "path": "other-languages/math/multiply-matrix/multiply-matrix.cpp", "content": "/*\nMultiplicação de matrizes (método trivial)\nAutor: \n ?\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo: \n math\nDescrição: \n É o algoritmo trivial para multiplicação de duas matrizes A e B, onde \n A é uma matriz m x n e B é uma matriz n x p, a partir da definição \n matemática.\nComplexidade de tempo: \n O(m*n*p)\nDificuldade: \n facil\n*/\n\n#include \n\nconst int m = 3;\nconst int n = 5;\nconst int p = 4;\n\n/*\nParâmetros:\na: matriz (m x n)\nb: matriz (n x p)\nc: matriz para armazenar o resultado (m x p) \n*/\n\nvoid matrix_multiplication(int a[m][n], int b[n][p], int c[m][p]) {\n int i, j, k;\n \n for (i = 0; i < m; i++)\n for (j = 0; j < p; j++)\n c[i][j] = 0;\n \n for (i = 0; i < m; i++)\n for (j = 0; j < p; j++)\n for (k = 0; k < n; k++) \n c[i][j] += a[i][k] * b[k][j];\n}\n\nint main( ) {\n\n int a[m][n] = { \n {1, 2, 3, 4, 5},\n {6, 7, 8, 9, 10},\n {11, 12, 13, 14, 15}};\n int b[n][p] = {\n {1, 2, 3, 4},\n {5, 6, 7, 8},\n {9, 10, 11, 12},\n {13, 14, 15, 16},\n {17, 18, 19, 20}}; \n int c[m][p];\n \n matrix_multiplication(a, b, c);\n \n for (int i = 0; i < m; i++) {\n for (int j = 0; j < p; j++) \n std::cout << c[i][j] << \" \";\n std::cout << \"\\n\";\n }\n\n return 0;\n}\n" }, { "path": "other-languages/math/n-root/MetodosNumericos.java", "content": "/*\nMétodo numérico para resolução de raiz enésima\nAutor:\n ?\nColaborador:\n Guilherme de Sales Orioli gui.orioli@gmail.com\nTipo:\n math\nDescrição:\n Tira a raíz n-ésima de x, permitindo um erro máximo de error-allowed\nExemplo:\n root(-123,5,0.0001);\n \n Saída: -2.618068900925607\n \nComplexidade:\n ?\nDificuldade:\n ?\n*/\n\npublic class MetodosNumericos{\n\n public static void main(String args[]){\n System.out.println(root(16, 2, 0.000001));\n }\n \n \n public static double root (double x, int n, double error_allowed){\n double r,test=0;\n int i;\n boolean negative = false;\n boolean fraction = false;\n \n if (x < 0){\n if(n%2==0)\n return 0;\n negative = true;\n x = -x;\n }\n \n if ( (x>0) && (x<1)){\n x = 1/x;\n fraction = true;\n }\n \n r=x;\n test=x+1;\n while ( (test < x-error_allowed) || (test > x+error_allowed) ){\n if (test\n#include \n\nfloat recursive_pow (float x, int n)\n{\n\tif (n == 1)\n\t\treturn x;\n\n\tif (n == 0)\n\t\treturn 1;\n\t\n\tif (n < 0 && x != 0)\n\t\treturn 1 / recursive_pow(x, -n);\n\n\tif (x == 0)\n\t\treturn 0;\n\n\tfloat pow = recursive_pow (x, n/2);\n\tpow = pow * pow * recursive_pow(x, n % 2);\n\treturn pow;\n}\n\nint main(void)\n{\n\tfloat x[] = {-3, -2, -1, 0, 1, 2, 3};\n\tint n[] = {-3, -2, -1, 0, 1, 2, 3};\n\tint i;\n\tint j;\n\tfor (i = 0; i < 7; i++)\n\t\tfor (j = 0; j < 7; j++)\n\t\t\tprintf(\"%f^%d=%f\\n\",x[i], n[j], recursive_pow(x[i],n[j]));\n\t\n\treturn 0;\n}\n" }, { "path": "other-languages/math/stirlings-approximation/stirling.clj", "content": "(defn stirling [n]\n \"\n Fórmula de Stirling\n \n Autor:\n Pedro Menezes \n DiogoK \n Tipo:\n math\n Descrição:\n A Fórmula de Stirling estabelece uma aproximação assintótica para o fatorial de um número.\n Referências:\n http://pt.wikipedia.org/wiki/F%C3%B3rmula_de_Stirling\n \"\n (* (Math/sqrt (* 2 Math/PI n)) (Math/pow (/ n Math/E) n)))\n \n(dorun (for [n (range 1 10)] \n (println \"fat\" n \"~\" (stirling n))\n))" }, { "path": "other-languages/number-theory/euclid/euclid.lisp", "content": "#|\nAlgoritmo de Euclides\nAutor:\n Euclides de Alexandria\nColaborador:\n Daniel Valio\nTipo:\n number-theory\nDescricao:\n Algoritmo de Euclides em sua forma moderna.\nComplexidade:\n O(n^2) onde n e' o numero de digitos da entrada.\nDificuldade:\n facil\n|#\n\n(defun euclides (a b)\n (if (/= b 0)\n (euclides b (mod a b))\n a))\n" }, { "path": "other-languages/number-theory/euclid/euclid.rb", "content": "# encoding: utf-8\n\n=begin\nAlgoritmo de Euclides\nAutor:\n Euclides de Alexandria\nColaborador:\n Bruno Lara Tavares \n Liquen \nTipo:\n number-theory\nDescrição:\n Algoritmo de Euclides em sua forma moderna. Computa o máximo\n divisor comum (MDC) entre dois números inteiros. Parte do princípio de\n que o MDC não muda se o menor número for subtraído do maior. [1] [2]\nComplexidade:\n O(n^2), onde n é o número de dígitos da entrada. [3]\n O número de passos é no máximo\n log(max(a, b) * sqrt(5)) / log(phi),\n onde phi = 1.618... é a proporção áurea. [3]\nDificuldade:\n facil\nReferências:\n [1] http://en.wikipedia.org/wiki/Euclidean_algorithm\n [2] http://pt.wikipedia.org/wiki/Algoritmo_de_Euclides\n [3] http://mathworld.wolfram.com/EuclideanAlgorithm.html\n=end\n\ndef euclides(a, b)\n while b != 0\n a, b = b, a % b\n end\n a\nend\n\nputs euclides(1071, 462)\n" }, { "path": "other-languages/number-theory/inverse/inverse.c", "content": "/*\n\nInverse\nAutor:\n JoseFernandoTolentino (JoseFernandoTolentino@gmail.com)\nTipo:\n number-theory\nDescrição:\n Inverte os algarismos de um número\nComplexidade: \n Pior caso: O(infinito)\n Melhor caso: O(n)\nDificuldade:\n facil\nReferências:\n*/\n\n#include \n\nint inverse(int input)\n{\n int x=input;\n int output=0;\n while (x>0) {\n output = output * 10 + x % 10;\n x = x / 10;\n }\n return output;\n}\n\nint main()\n{\n int input = 12345;\n int output= inverse(input);\n printf(\"Numero=%d\\ninverso=%d\\n\", input, output);\n return 0;\n}\n \n" }, { "path": "other-languages/number-theory/modular-exponentiation/modular-exponentiation.cpp", "content": "/*\nExponenciação modular (utilizando representação binária)\nAutor: \n ?\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo:\n number-theory\nDescrição: \n É um algoritmo que realiza eficientemente a exponenciação modular, ou seja,\n calculos do tipo a^b mod n. Esse tipo de cálculo é de extrema importância\n para a teoria dos números e para a criptografia, é uma das operações mais\n importantes no método de criptografia RSA.\nComplexidade:\n O(log b)\nDificuldade: \n medio\nReferências:\n http://en.wikipedia.org/wiki/Modular_exponentiation\n Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. \n ISBN 978-0-262-53305-8. Página 957.\n*/\n\n#include \n\nint modular_exponentiation(int a, int b, int n) {\n int result, aux = 1;\n \n // aux: auxiliar para fazer a conversão binária de b\n // inicia com a potência de base 2 mais próxima de b\n while ( aux < b ) \n aux <<= 1;\n \n result = 1;\n \n // enquanto aux > 0\n while ( aux ) {\n result = (result*result) % n;\n \n // se o dígito de b for 1\n if ( b & aux )\n result = (a*result) % n; \n \n // divide por 2\n aux >>= 1;\n }\n \n return result;\n}\n\nint main( ) {\n \n std::cout << modular_exponentiation(5, 10, 30) << \"\\n\";\n std::cout << modular_exponentiation(3, 11, 5) << \"\\n\";\n std::cout << modular_exponentiation(11, 7, 17) << \"\\n\";\n \n return 0;\n}\n" }, { "path": "other-languages/number-theory/odd/odd.c", "content": "/*\nEncontrando números Ímpares\nAutor:\n ???\nColaborador:\n Filipe Saraiva (filip.saraiva@gmail.com)\nTipo:\n math\nDescrição:\n Dá-se um número inteiro não negativo; o algoritmo\n listará todos os números ímpares entre 0 e este número\n dado.\nComplexidade:\n O(n)\nDificuldade:\n fácil\n*/\n\n#include \n\n// Função para imprimir os números ímpares\n// entre '0' e um número máximo dado.\nvoid numerosImpares(int num){\n \n int contador = 0;\n \n /*\n * Maneira convencional: caso o número a ser comparado\n * tiver o resto da divisão diferente de '0', quer dizer que\n * o número não é um múltiplo de 2 - definição de número ímpar.\n */\n for(contador = 0; contador <= num; contador++){\n \n if((contador % 2) != 0){\n printf(\"%d \", contador);\n }\n }\n \n /*\n * Maneira esperta - sabemos que o primeiro número ímpar é igual à 1.\n * Daí, basta apenas incrementar o contador em mais duas unidades.\n * Todos os demais números serão ímpares.\n * \n * Descomente a rotina abaixo para a \"Maneira esperta\".\n */\n// for(contador = 1; contador <= num; contador = contador + 2){\n// printf(\"%d \", contador);\n// }\n \n printf(\"\\n\");\n}\n\n// Função main\nint main(){\n \n // Número máximo a ser utilizado.\n // Troque-o por outro número qualquer.\n int limite = 13;\n \n // Chamada da função numerosImpares\n numerosImpares(limite);\n \n return 0;\n}\n" }, { "path": "other-languages/number-theory/odd-even/odd-even.c", "content": "/*\nPar ou impar\nAutor:\n ?\nColaboradores:\n Geraldo Neto email (glnetinho@hotmail.com)\n Prdro Arthur Duarte (pedroarthur.jedi@gmail.com)\nTipo:\n number-theory\nDescricao:\n Verifica se os números são impares ou pares.\nComplexidade:\n O(n), Através de operação módulo\n O(1), Através de operador binário\nDificuldade:\n facil\n*/\n\n#include \n\n/*\n Macro: retorna 1 se o número for impar ou 0 caso contrário\n*/\n#define oddOrEven(a) ((a) & 1)\n\nvoid main(void)\n{\n int v[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};\n int i, par = 0, impar = 0;\n \n for (i=0; i<=8; i++){ \n if(v[i]%2==0){\n par=par+1;\n } else {\n impar=impar+1;\n }\n }\n printf(\"%d numeros pares e %d impares\\n\", par, impar);\n}\n" }, { "path": "other-languages/number-theory/sieve/sieve.cpp", "content": "/*\nCrivo de Eratóstenes\nAutor:\n Eratóstenes de Cirene\nColaborador:\n ?\nTipo:\n number-theory\nDescrição:\n O Crivo de Eratóstenes implementado em C++. É um algoritmo que\n serve para encontrar todos os números primos até um limite especificado.\nComplexidade:\n O(n log log n)\nDificuldade:\n medio\nReferências: \n [1] http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes\n [2] http://mathworld.wolfram.com/SieveofEratosthenes.html\n*/\n\n#include \n#include \n\n/* \nA função pede dois parâmetros: \n - primo: um array de booleanos\n - n: o tamanho do array primo\nApós a execução do algoritmo, o vetor primo será tal que o valor da i-ésima\nposição será true se (i + 1) for primo, ou false caso contrário. (O 1 somado\nse deve ao fato de C++ ser uma linguagem com arrays que começam em 0.\n*/\n\nvoid eratostenes(bool primo[], int n) {\n int i, j, parada;\n \n primo[0] = false; \n for (i = 1; i < n; i++) {\n primo[i] = true;\n }\n \n parada = (int) sqrtf(n);\n \n for (i = 1; i < parada; i++) {\n if ( primo[i] == false ) \n continue;\n for (j = 2*i + 1; j < n; j += (i + 1)) \n primo[j] = false;\n }\n}\n\nint main( ) {\n \n const int n = 25;\n bool primo[n];\n \n eratostenes(primo, n);\n \n for (int i = 0; i < 25; i++)\n std::cout << i + 1 << \" \" << primo[i] << \"\\n\"; \n\n return 0;\n}\n" }, { "path": "other-languages/number-theory/sieve/sieve.lisp", "content": "#|\nCrivo de Eratostenes\nAutor:\n Eratostenes de Cirene\nColaborador:\n Daniel Valio \nTipo:\n number-theory\nDescricao:\n Encontra todos os primos entre dois nu'meros.\nComplexidade:\n ?\nDificuldade:\n Facil/medio\n|#\n\n(defun primop (numero)\n (when (> numero 1)\n (loop for i from 2 to (isqrt numero) never (zerop (mod numero i)))))\n\n(defun proximo-primo (numero)\n (loop for i from numero when (primop i) return i))\n\n;;; Agora vem a parte magica.\n\n(defmacro with-gensyms ((&rest names) &body body)\n `(let ,(loop for n in names collect `(,n (gensym)))\n ,@body))\n\n;;; A macro do-primes aceita uma lista com nome de uma variavel, o limite inferior\n;;; e o limite superior. Exemplo:\n;;;\n;;; (do-primes (alguma-var-inutil 0 100)\n;;; (print alguma-var-inutil))\n;;;\n;;; Esse exemplo retorna todos os primos de 0 a 100.\n\n(defmacro do-primes ((var start end) &body body)\n (with-gensyms (ending-value-name)\n `(do ((,var (proximo-primo ,start) (proximo-primo (1+ ,var)))\n\t (,ending-value-name ,end))\n\t ((> ,var ,ending-value-name))\n ,@body)))\n\n" }, { "path": "other-languages/pattern-matching/lcs/lcs.rb", "content": "# LCS (Longest Common Subsequence)\n# Autor:\n# ?\n# Colaborador:\n# Luiz Fernando Oliveira Corte Real \n# Tipo:\n# pattern-matching\n# Descrição:\n# Este algoritmo calcula a maior string que subsequência de outras duas,\n# chamada de subsequência comum máxima ou, em inglês, longest common\n# subsequence (LCS).\n#\n# Por exemplo, dada a string 'banana' e a string 'abacate', a maior string\n# que é substring das duas é 'baa', que pode ser encontrada se pegarmos a\n# primeira (b), a segunda (a) e quarta letra (a) da palavra 'banana', ou a\n# segunda (b), a terceira (a) e a quinta letra (a) da palavra 'abacate'.\n#\n# O algoritmo baseia-se em programação dinâmica para calcular, primeiro,\n# o tamanho da maior substring das duas strings dadas. Ele faz isso\n# colocando, na matriz lcs_matrix, o tamanho da maior substring das duas até\n# certo ponto. Ou seja, na posição [i, j] da matriz teremos o tamanho da\n# LCS das strings string1[1..i] e string2[1..j] (os primeiros i caracteres\n# da string1 e os primeiros j caracteres da string2). O algoritmo vai\n# preenchendo essa matriz pelas linhas, com base nas strings e numa\n# fórmula de recorrência. No fim, o tamanho da LCS das duas strings estará\n# na última posição preenchida da matriz.\n#\n# Para recuperar qual é essa LCS, o algoritmo percorre a matriz procurando\n# quais foram as posições das strings que fizeram o tamanho ser\n# incrementado.\n# Complexidade:\n# O(nm), onde n e m são os tamanhos das strings dadas\n# Referências:\n# http://en.wikipedia.org/wiki/Longest_common_subsequence_problem\n# Licença:\n# BSD\n\nclass LCS\n def initialize(string1, string2)\n @string1 = string1\n @string2 = string2\n end\n\n def length\n @lcs_matrix ||= compute_lcs_matrix\n return @lcs_matrix[@string1.size][@string2.size]\n end\n\n def string\n return '' if @string1.empty? or @string2.empty?\n @lcs_matrix ||= compute_lcs_matrix\n @lcs_string ||= find_lcs_in_matrix\n return @lcs_string\n end\n\n private\n def compute_lcs_matrix\n counting = []\n (@string1.size+1).times { counting << Array.new(@string2.size+1, 0) }\n @string1.size.times do |i|\n @string2.size.times do |j|\n if @string1[i] == @string2[j]\n counting[i+1][j+1] = counting[i][j] + 1\n else\n counting[i+1][j+1] = [counting[i+1][j], counting[i][j+1]].max\n end\n end\n end\n return counting\n end\n\n def find_lcs_in_matrix\n return recursive_find_lcs_in_matrix(@string1.size, @string2.size)\n end\n\n def recursive_find_lcs_in_matrix(i, j)\n return '' if i == 0 or j == 0\n if @string1[i-1] == @string2[j-1]\n return recursive_find_lcs_in_matrix(i-1, j-1) + @string1[i-1].chr\n end\n if @lcs_matrix[i][j-1] > @lcs_matrix[i-1][j]\n return recursive_find_lcs_in_matrix(i, j-1)\n end\n return recursive_find_lcs_in_matrix(i-1, j)\n end\nend\n\n###################################################\n# Exemplos de uso, com resultados esperados ao lado\n###################################################\n\nputs LCS.new('a string', 'another string').string # 'a string'\nputs LCS.new('yes', 'not').length # 0\nputs LCS.new('french', 'trench').string # 'rench'\n" }, { "path": "other-languages/physics/ballistic/ballistic.lisp", "content": "#|\nBalistica\nAutor:\n ?\nColaborador:\n Daniel Valio \nTipo:\n physics\nComplexidade:\n O(1)\nDificuldade:\n Facil\n|#\n\n(defun backend-tiro (vetor-horizontal vetor-vertical gravidade \n\t\t &optional (x 0) (y 0) (time 0) (angulo 0))\n (if (> y 0)\n (backend-tiro vetor-horizontal vetor-vertical \n\t\t gravidade (* time vetor-horizontal)\n\t\t (- (+ y (* time vetor-vertical))\n\t\t (* gravidade (expt time 2)))\n\t\t (1+ time))\n (list angulo x y)))\n(defun simula-tiro (angulo forca gravidade y)\n (backend-tiro (* forca (cos angulo))\n\t\t(* forca (sin angulo))\n\t\tgravidade 0 y 0 angulo))" }, { "path": "other-languages/puzzle/hanoi/hanoi.cpp", "content": "/*\nTorre de Hanói\nAutor:\n ?\nColaborador:\n Ramon Caldeira (ramoncaldeira_328@hotmail.com)\nTipo:\n misc\nDescrição:\n O algoritmo resolve recursivamente o puzzle Torre de Hanói para n discos.\n A idéia é basicamente resolver a torre para menos discos usando o pino\n auxiliar como destino e resolvê-la novamente.\n O caso base: resolver a torre com um disco \nComplexidade: \n ?\nDificuldade:\n medio\n*/\n\n#include \n\nconst char* pino[3] = {\n \"pino inicial\", \n \"pino auxiliar\", \n \"pino destino\"\n};\n\n/*\n @param nDiscos => número de discos que a torre inicialmente contém\n @param pInicial => pino onde se colocam os discos inicialmente\n @param pAuxiliar => pino usado momentâneamente para trocar os discos de pino\n @param pDestino => pino aonde os discos terminam\n*/\nvoid hanoi(int nDiscos, int pInicial = 0, \n int pAuxiliar = 1, int pDestino = 2) \n{\n if(!nDiscos) return;\n \n hanoi(nDiscos - 1, pInicial, pDestino, pAuxiliar);\n std::cout << \"move disco do \" << pino[pInicial]\n << \" ao \" << pino[pDestino] << std::endl;\n hanoi(nDiscos - 1, pAuxiliar, pInicial, pDestino);\n}\n\n/* rotina de teste */\nint main() {\n int discos = 3;\n hanoi(discos);\n \n std::cin.get();\n}\n" }, { "path": "other-languages/puzzle/sudoku-validation/sudoku-validation.cpp", "content": "/*\nValida solução de sudoku\nAutor:\n ?\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo:\n puzzle\nDescrição:\n Algoritmo que verifica se um jogo de sudoku está corretamente preenchido\n ou não, de acordo com as regras do jogo.\n Utiliza a ideia de que, se um conjunto tem somente de 1 a 9 sem duplicidade, \n então a soma de todos os elementos é constante.\nComplexidade:\n O(1)\nDificuldade:\n facil\nReferências:\n http://en.wikipedia.org/wiki/Sudoku\n*/\n\n#include \n\nbool validate_sudoku(int sudoku[9][9]) {\n // 1 + 2 + 3 + 4 + ... + 9\n const int SUM_9 = 45;\n\n // inicializa somas com 0 \n int sum_line[9], sum_column[9], sum_matrix[3][3];\n \n int i, j;\n\n for (i = 0; i < 9; i++)\n sum_line[i] = sum_column[i] = sum_matrix[i/3][i%3] = 0;\n \n \n for (i = 0; i < 9; i++)\n for (j = 0; j < 9; j++) { \n sum_line[i] += sudoku[i][j];\n sum_column[j] += sudoku[i][j];\n sum_matrix[i/3][j/3] += sudoku[i][j];\n } \n \n for (i = 0; i < 9; i++)\n if ( sum_column[i] != SUM_9 || sum_line[i] != SUM_9 || sum_matrix[i/3][i%3] != SUM_9 )\n return false;\n \n return true; \n}\n\nint main( ) {\n\n int game[9][9] = {\n {5, 3, 4, 6, 7, 8, 9, 1, 2},\n {6, 7, 2, 1, 9, 5, 3, 4, 8},\n {1, 9, 8, 3, 4, 2, 5, 6, 7},\n {8, 5, 9, 7, 6, 1, 4, 2, 3},\n {4, 2, 6, 8, 5, 3, 7, 9, 1},\n {7, 1, 3, 9, 2, 4, 8, 5, 6},\n {9, 6, 1, 5, 3, 7, 2, 8, 4},\n {2, 8, 7, 4, 1, 9, 6, 3, 5},\n {3, 4, 5, 2, 8, 6, 1, 7, 9}};\n\n std::cout << validate_sudoku(game);\n \n return 0;\n}\n" }, { "path": "other-languages/search/binary-search/BuscaBinaria.java", "content": "/*\n * BuscaBinaria\n * Autor:\n * Jon Bentley\n * Colaborador:\n * Fabiano Sobreira\n * Tipo:\n * search\n * Descrição:\n * A pesquisa ou busca binária (em inglês binary search algorithm ou binary\n * chop) é um algoritmo de busca em vetores que requer acesso aleatório aos\n * elementos do mesmo. Ela parte do pressuposto de que o vetor está ordenado\n * e realiza sucessivas divisões do espaço de busca (divisão e conquista)\n * comparando o elemento buscado (chave) com o elemento no meio do vetor.\n * Complexidade:\n * ?\n * Dificuldade:\n * fácil\n * Referências:\n * http://pt.wikipedia.org/wiki/Pesquisa_binária\n */\npublic class BuscaBinaria {\n\n private int[] vetor;\n private int valorProcurado;\n\n private int menor;\n private int maior;\n\n public BuscaBinaria(int[] vetor, int valorProcurado) {\n this.vetor = vetor;\n this.valorProcurado = valorProcurado;\n menor = 0;\n maior = vetor.length - 1;\n }\n\n public int getPosicao() {\n while (menor < maior) {\n int meio = menor + ((maior - menor) / 2);\n int valorMeio = vetor[meio];\n if (valorProcurado < valorMeio)\n maior = meio;\n else if (valorProcurado > valorMeio)\n menor = meio + 1;\n else\n return meio;\n }\n return -1;\n }\n\n /*\n * Método de exemplo para verificação do algorítimo. O algoritimo pode ser\n * executado da seguinte maneira: java BuscaBinaria 1000 799\n */\n public static void main(String[] args) {\n if (args.length < 2)\n throw new IllegalArgumentException(\"informe o tamanho do vetor e o valor procurado\");\n \n int tamanho = Integer.parseInt(args[0]);\n int alvo = Integer.parseInt(args[1]);\n\n int[] vetor = new int[tamanho];\n for (int i = 0; i < vetor.length; i++)\n vetor[i] = i;\n\n BuscaBinaria bs = new BuscaBinaria(vetor, alvo);\n int resultado = bs.getPosicao();\n\n if (resultado == -1)\n System.out.println(\"Não encontrado.\");\n else\n System.out.println(\"Encontrado na posição: \" + resultado + \".\");\n }\n}\n" }, { "path": "other-languages/search/linear-search/linear-search.rb", "content": "\n=begin\n Linear Search\nAutor:\n ?\nColaborador:\n José Alberto O. Morais Filho (j.moraisg12@gmail.com)\nTipo:\n search\nDescrição:\n Utiliza força bruta em um array para retornar a posição de um valor nesse array, ou retornar -1, se nada\n for encontrado.\nComplexidade:\n O(n)\nDificuldade:\n fácil\n=end\n\n# Entrada:\n# array = vetor onde o valor será pesquisado\n# search = valor procurado\n# Saída:\n# a posição da primeira ocorrência do valor, ou -1, caso o valor não for encontrado\n\ndef linear_search(array, search)\n array.each_index {|i| return i if array[i] == search}\n -1\nend\n\n# Exemplos\n\na = [1,5, 6, 3, 7,4]\n\nprint linear_search(a, 6)\nprint linear_search(a, 60)\n\n" }, { "path": "other-languages/search/simul-smaller-higher/simul-smaller-higher.cpp", "content": "/*\nMenor e maior elemento simultâneo\nAutor: \n ?\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo: \n search\nDescrição: \n É um algoritmo que pesquisa o menor e o maior elemento do vetor\n simultaneamente, economizando, assim, comparações. Enquanto utizando \n pesquisa de menor e maior elementon separadamente são necessárias\n 2n-2 comparações, com esse algoritmo, o número de comparações é reduzido\n para aproximadamente 1,5n. [1]\n O algoritmo funciona da seguinte forma: divide-se o vetor em pares, compara-se\n os dois elementos dos pares, compara-se o menor com o valor minimo armazenado\n e o maior com o valor máximo armazenado, assim, tem um custo de 3 comparações\n para cada 2 elementos, resultando em aproximadamente 1,5n comparações.\nComplexidade:\n O(n)\nDificuldade: \n facil\nReferências:\n [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition, páginas 214-215\n*/\n\n#include \n\n/*\nParâmetros:\na: o vetor\nn: o número de elementos\nmin: variável para armazenar a posição do menor valor\nmax: variável para armazenar a posição do maior valor\n*/\n\nvoid min_max(int a[], int n, int &min, int &max) {\n int i = 0;\n \n min = max = 0;\n // valida o caso do número de elementos ser ímpar\n if ( n % 2 != 0 ) {\n i = 1;\n }\n \n for (; i < n; i += 2) {\n if ( a[i] < a[i + 1] ) {\n if ( a[i] < a[min] )\n min = i;\n if ( a[i + 1] > a[max] )\n max = i + 1;\n } else {\n if ( a[i + 1] < a[min] )\n min = i + 1;\n if ( a[i] > a[max] )\n max = i;\n }\n }\n}\n\nint main( ) {\n \n int a[] = {8, 2, 5, 3, 1, 7, 6, 4};\n int min, max;\n \n min_max(a, 8, min, max);\n std::cout << \"Menor valor: \" << a[min] << \"\\n\";\n std::cout << \"Maior valor: \" << a[max] << \"\\n\"; \n \n return 0;\n}\n" }, { "path": "other-languages/sequence/token/token.php", "content": "\nColaborador:\n Sérgio Mandrake \nTipo:\n sequence\nDescrição:\n Gera um token aleatório\nComplexidade:\n ?\nDificuldade:\n facil\n*/\n\nfunction token($comprimento = 6) {\n $caracteres = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';\n $totalCarac = strlen($caracteres) -1;\n $resultado = '';\n for ($i = 0; $i < $comprimento; $i++) {\n $resultado .= $caracteres[mt_rand(0, $totalCarac)];\n }\n\n return $resultado;\n}\n\necho token(5);\n" }, { "path": "other-languages/sequence/token/token.rb", "content": "# -*- coding: UTF-8 -*-\n\n=begin\nToken\n\nAutor:\n ?\nColaborador:\n Bruno Lara Tavares \n Felipe Djinn \nTipo:\n sequence\nDescrição:\n Gera um token aleatório\nComplexidade:\n ?\nDificuldade:\n facil\n=end\n\ndef token(length = 10)\n rand(36**length).to_s 36\nend\n\n\n\"\"\"\nExamples\n\"\"\"\n\nputs \"Token com 10 caracteres (padrão): \" + token()\nputs \"Token com 5 caracteres: \" +token(5)\nputs \"Token com 15 caracteres \" +token(15)\n" }, { "path": "other-languages/sorting/bozosort/bozosort.lisp", "content": "#|\nBozosort (a.k.a Bogosort)\nAutor:\n Bozo\nTipo:\n sorting\nDescricao:\n Embaralha um vetor indefinidamente, ate' que os numeros estejam em ordem.\nComplexidade:\n O(infinito)\nPS: Essa versao trabalha com listas, e nao vetores de fato.\n|#\n\n(defun shuffle-list (l)\n (loop for i below (length l) do\n (rotatef\n\t (elt l i)\n\t (elt l (random (length l)))))\n l)\n(defun bozosort (lista)\n (if (equalp lista (sort lista #'<))\n lista\n (bozosort (shuffle-list lista))))\n" }, { "path": "other-languages/sorting/bozosort/bozosort.php", "content": "\";\n\t\t\tprint_r(($ordenado==true)? $valores: \"\");\n\t\t}\n\t\t\n\t}\n\t\n\t// Passando um array com valores a serem ordenados\n\tbogo(array(3,5,2,1));\n\t\n?>\n" }, { "path": "other-languages/sorting/bozosort/bozosort.rb", "content": "=begin\nBozosort\nAutor:\n Bozo\nColaborador:\n Caio\nTipo:\n sorting\nDescrição:\n Embaralha um vetor indefinidamente, até que os números estejam em ordem.\nComplexidade: \n O(infinito)\nDificuldade:\n facil\nReferências:\n http://nerdson.com/blog/libbozo-01/\n http://pt.wikipedia.org/wiki/Bogosort\n=end\n\nrequire 'test/unit'\n\nclass Array\n def bozosort\n list = self.sort\n while self != list\n self.shuffle!\n end\n self\n end\nend \n\nclass TestBozosort < Test::Unit::TestCase\n def test_bozosort\n randon_array = Array.new(rand(20)).map{rand(99999999)}\n sorted_array = randon_array.sort\n assert_equal randon_array.bozosort, sorted_array\n end\nend\n" }, { "path": "other-languages/sorting/bubblesort/bubblesort.lisp", "content": "#|\nBubble sort\nAutor: Desconhecido\nTipo: Ordenacao de vetores\nDescricao: Compara elementos dois a dois e checa se estao na ordem correta.\nComplexidade: Pior caso: O(n²)\n Melhor caso: O(n²)\n|#\n\n(defun bubble-sort (array)\n (let ((result (copy-seq array)))\n (loop for i from (1- (length result)) downto 0 do\n (loop for j from 0 to i\n when (< (aref result i) (aref result j))\n do (rotatef (aref result i) (aref result j))))\n result))\n\n" }, { "path": "other-languages/sorting/bubblesort/bubblesort.php", "content": "\n" }, { "path": "other-languages/sorting/fisher-yates/fisher-yates.c", "content": "/*\nFisher–Yates shuffle, Knuth shuffle (Durstenfeld's Solution)\nAutor:\n Ronald Fisher, Frank Yattes, Donald Knuth, Richard Durstenfeld\nColaborador:\n Anderson \"Cacovsky\" Marques Ferraz\n amarquesferraz@gmail.com\nTipo:\n sorting\nDescrição:\n Embaralha um vetor de numeros sequenciais. Nao utiliza nenhum vetor\n auxiliar (in-place) e so realiza tantos sorteios quanto posicoes do\n vetor.\nComplexidade:\n O(n)\nDificuldade:\n medio\nReferências:\n http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle\nLicenca:\n LGPL\n*/\n\n\n\n#include \n#include \n#include \n\n/**\n * gera uma lista ordenada\n */\nint * gera_vetor_ordenado(int qtde_elementos)\n{\n int i;\n int *resultado= (int*) malloc(qtde_elementos*sizeof(int));\n\n for (i=0; i0){\n int k = rand() % (elementos_restantes); //passo 2\n\n //passo 3\n int tmp = elementos[k];\n elementos[k] = elementos[elementos_restantes-1];\n elementos[elementos_restantes-1] = tmp;\n\n elementos_restantes--; //passo 4\n }\n\n printf(\"Vetor embaralhado: \");\n imprime_vetor(elementos, N);\n\n return 0;\n}\n" }, { "path": "other-languages/sorting/heapsort/heapsort.c", "content": "/*\nHeap Sort\nAutor:\n Robert W. Floyd e J.W.J. Williams.\nColaborador:\n Ramon Caldeira Faria (ramoncaldeira_328@hotmail.com)\nTipo:\n sorting\nDescrição:\n O algoritmo serve para ordenar uma estrutura de dados,\n no caso desta implementação um vetor. \nComplexidade: \n O(n lgn)\nDificuldade:\n medio\n*/\n\nvoid buildMaxHeap(int*, int);\nvoid maxHeapify(int*, int, int);\nvoid swap (int*, int, int);\n\n/***\n - transforma o array numa heap de máximo\n heap: árvore binária com propriedade de heap\n propriedade de heap: um nó deve ser maior que seus filhos.\n \n o array como arvore binaria:\n \n | raiz | n1 | n1 | n2 | n2 | n2 | n2 | ...\n \n - para todos os filhos:\n - retira o nó raiz (maior número) e separa\n - reconstrói a heap\n***/\nvoid heapSort(int* array, int size) { \n buildMaxHeap(array, size);\n \n int n = size;\n \n for (int i=(size-1); i>0; i--) { \n swap(array, i , 0);\n maxHeapify(array, 0, --n);\n }\n}\n\n/* percorre todos os nós que não são folha\ne reconstroe-se uma sub-heap tendo ele como raiz\nde baixo pra cima */\nvoid buildMaxHeap(int* array, int size) { \n for (int i = size/2 - 1; i >= 0; i--)\n maxHeapify(array, i , size);\n}\n\n/* \n aplica a propriedade de heap\n*/\nvoid maxHeapify(int* array, int pos, int n) { \n int max = 2 * pos + 1, right = max + 1;\n \n if (max < n) { \n if ( right < n && array[max] < array[right])\n max = right;\n \n if (array[max] > array[pos]) { \n swap(array, max, pos);\n maxHeapify(array, max, n);\n }\n }\n}\n\nvoid swap ( int* v, int i, int j ) {\n int aux = v [i];\n v [i] = v [j];\n v [j] = aux;\n}\n" }, { "path": "other-languages/sorting/insertionsort/insertionsort.cpp", "content": "/*\nInsertionSort\nAutor:\n ?\nColaborador: \n Willian\nTipo:\n sorting\nDescrição:\n Varre o vetor organizando-o em ordem crescente.\n Só pula para o próximo elemento depois de organizar todos os elementos anteriores.\nComplexidade:\n O(n²)\nDificuldade:\n facil\nReferências:\n http://pt.wikipedia.org/wiki/Insertion_sort\n*/\n\n#include \n\nusing namespace std;\n\n/*\n * Parâmetros\n * int vetor[]\n * Vetor de números inteiros\n * int tam\n * Quantidade de elementos do vetor 'vetor[]'\n */\nvoid insertionSort(int vetor[], int tam)\n{\n //Vamos começar o loop pelo segundo elemento do vetor\n for(int i=1;i vetor[proximo])\n {\n tmp = vetor[anterior];\n vetor[anterior] = vetor[proximo];\n vetor[proximo] = tmp;\n }\n else\n troca = false;\n\n anterior--;\n proximo = anterior + 1;\n\n //Verificando o limite do vetor\n if (anterior<0)\n troca = false;\n } while(troca);\n }\n}\n\n//exemplo de uso\nint main(void)\n{\n //Criando um vetor de testes\n int vetor[] = { 98, 78, 2, 4, 100, -2 };\n int tam = sizeof(vetor) / sizeof(int);\n\n //Chamando a função de ordenação com o vetor e o tamanho\n insertionSort(vetor, tam);\n\n //Imprimindo\n for(int i=0; i $vetor[$proximo])\n {\n $tmp = $vetor[$anterior];\n $vetor[$anterior] = $vetor[$proximo];\n $vetor[$proximo] = $tmp;\n }\n else\n $troca = false;\n\n $anterior--;\n $proximo = $anterior + 1;\n\n if ($anterior<0)\n $troca = false;\n }\n }\n\t\n\treturn $vetor;\n\t\n}\n\n\n$vetor = array(98, 78, 2, 4, 100, -2 );\n$vetor = insertionSort($vetor);\n\nfor($i=0; $i';\n\n?>" }, { "path": "other-languages/sorting/insertionsort/insertionsort.rb", "content": "# encoding: utf-8\n\n=begin\nInsertion Sort\nAutor: \n ?\nTipo:\n sorting\nColaborador:\n Bruno Lara Tavares \nDescrição:\n Percorre uma lista da esquerda para direita e vai deixando os elementos\n mais a esquerda ordenados à medida que avança pela lista.\nComplexidade:\n Pior caso: O(n²)\n Melhor caso: O(n)\nDificuldade:\n Facil\nReferencia:\n http://pt.wikipedia.org/wiki/Insertion_sort\n=end\n\nclass Array\n def insertion_sort!()\n (1..self.size-1).each do |i|\n elemento = self[i]\n j = i - 1\n\n while j >= 0 && self[j] > elemento\n self[j+1] = self[j]\n j -= 1\n self[j+1] = elemento\n end\n end\n self\n end\nend\n\nputs [5,6,8,1].insertion_sort!.inspect\n" }, { "path": "other-languages/sorting/mergesort/mergesort.c", "content": "/*\nMergesort\nAutor:\n\tJohn von Neumann, em 1945\nColaborador:\n\tLuiz Fernando Oliveira Corte Real (luiz@vidageek.net)\nTipo:\n\tsorting\nDescrição:\n\tO algoritmo ordena um vetor dividindo-o pela metade e, depois de processar\n\tcada metade recursivamente, intercala as metades ordenadas.\nComplexidade:\n\tO(n lgn)\nDificuldade:\n\tfácil\nReferências:\n\t[1] http://en.wikipedia.org/wiki/Merge_sort\n*/\n\n#include \n#define TAMANHO_MAXIMO 100000\n\n/* Intercala duas metades ordenadas do vetor v: de inicio até meio-1 e de meio até fim-1 */\nvoid intercala(int v[], int inicio, int meio, int fim) {\n\tint vetor_auxiliar[TAMANHO_MAXIMO];\n\tint indice_parte_1, indice_parte_2, indice_vetor_auxiliar;\n\tindice_parte_1 = inicio;\n\tindice_parte_2 = meio;\n\tindice_vetor_auxiliar = 0;\n\t/* Mescla as metades até uma delas acabar */\n\twhile (indice_parte_1 < meio && indice_parte_2 < fim) {\n\t\tif (v[indice_parte_1] < v[indice_parte_2]) {\n\t\t\tvetor_auxiliar[indice_vetor_auxiliar] = v[indice_parte_1];\n\t\t\tindice_parte_1++;\n\t\t} else {\n\t\t\tvetor_auxiliar[indice_vetor_auxiliar] = v[indice_parte_2];\n\t\t\tindice_parte_2++;\n\t\t}\n\t\tindice_vetor_auxiliar++;\n\t}\n\t/* Uma das metades pode ter ficado com elementos sobrando; apenas copiamos esses elementos */\n\twhile (indice_parte_1 < meio) {\n\t\tvetor_auxiliar[indice_vetor_auxiliar] = v[indice_parte_1];\n\t\tindice_parte_1++;\n\t\tindice_vetor_auxiliar++;\n\t}\n\twhile (indice_parte_2 < meio) {\n\t\tvetor_auxiliar[indice_vetor_auxiliar] = v[indice_parte_2];\n\t\tindice_parte_2++;\n\t\tindice_vetor_auxiliar++;\n\t}\n\t/* Copia o vetor auxiliar no lugar certo em v (de trás pra frente para não\n\t * ter que calcular o tamanho do pedaço que vamos copiar; esse tamanho já\n\t * está na variável indice_vetor_auxiliar) */\n\twhile (indice_vetor_auxiliar > 0) {\n\t\tindice_vetor_auxiliar--;\n\t\tv[inicio + indice_vetor_auxiliar] = vetor_auxiliar[indice_vetor_auxiliar];\n\t}\n}\n\n/* Ordena o vetor v de inicio até fim-1 */\nvoid mergesort_recursivo(int v[], int inicio, int fim) {\n\tint meio = (inicio + fim) / 2;\n\t/* Só chama a recursão na primeira metade se houver mais de um elemento lá */\n\tif (inicio < meio - 1) {\n\t\tmergesort_recursivo(v, inicio, meio);\n\t}\n\t/* Idem para a segunda metade */\n\tif (meio < fim - 1) {\n\t\tmergesort_recursivo(v, meio, fim);\n\t}\n\tintercala(v, inicio, meio, fim);\n}\n\nvoid mergesort(int v[], int n) {\n\tmergesort_recursivo(v, 0, n);\n}\n\nint main() {\n\tint vetor[] = { 5, 14, 8, 17, 1, -3, 9};\n\tint n = 7; /* número de elementos no vetor */\n\tint i;\n\tmergesort(vetor, n);\n\tprintf(\"vetor ordenado:\");\n\tfor (i = 0; i < n; i++) {\n\t\tprintf(\" %d\", vetor[i]);\n\t}\n\tprintf(\"\\n\");\n\treturn 0;\n}\n" }, { "path": "other-languages/sorting/mergesort/mergesort.rb", "content": "\n=begin\n Mergesort\nAutor:\n ?\nColaborador:\n José Alberto O. Morais Filho (j.moraisg12@gmail.com)\nTipo:\n sorting\nDescrição:\n Um dos melhores algoritmos de ordenação existente. Recebe um vetor, e, recursivamente, aplica a função Merge nos\n subvetores. A função merge recebe dois subvetores e os agrupa em um array ordenado.\nComplexidade:\n O(n log n)\nDificuldade:\n médio\nReferências:\n [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 29-34)\n=end\n\ndef merge(array, left, mid, right)\n n1 = mid - left + 1\n n2 = right - mid\n\n l = Array.new(n1 + 1) {0}\n r = Array.new(n2 + 1) {0}\n\n for i in 0...n1 do\n l[i] = array[left + i]\n end\n\n for j in 1..n2 do\n r[j - 1] = array[mid + j]\n end\n\n l[n1] = 999999\n r[n2] = 999999\n\n i = 0\n j = 0\n\n for k in left..right do\n if l[i] <= r[j] then\n array[k] = l[i]\n i += 1\n else\n array[k] = r[j]\n j += 1\n end\n end\nend\n\ndef mergesort(array, left, right)\n if left < right then\n mid = (left + right) / 2\n mergesort(array, left, mid)\n mergesort(array, mid + 1, right)\n merge(array, left, mid, right)\n end\nend\n\na = [5, 3, 4, 1, 9, 7, 2, 6, 8]\nmergesort(a, 0, 8)\nprint a\n\nputs\n\nb = [8, 1, 3, 2, 5, 7, 6, 4]\nmergesort(b, 0, 7)\n" }, { "path": "other-languages/sorting/quicksort/quicksort.c", "content": "/*\nQuicksort\nAutor:\n C.A.R. Hoare\nColaborador:\n Dayvid Victor (victor.dvro@gmail.com)\nTipo:\n sorting\nDescrição:\n Quicksort é um algorítmo de ordenação de vetores cuja estratégia é\n dividir para conquistar. Basicamente o algorítmo organiza os elementos\n dos vetores de forma que os menores estejam antes dos maiores.\n Esse passo é feito recursivamente até que a lista completa esteja ordenada.\nComplexidade: \n O(n log(n)) - Melhor caso e médio caso.\n O(n²) - Pior caso.\nDificuldade:\n facil\nReferências: (opcional)\n http://pt.wikipedia.org/wiki/Quicksort#C\n*/\n\n\n#include \n#include \n\nvoid swap (int vector[], int a, int b)\n{\n\tint temp = vector[a];\n\tvector[a] = vector[b];\n\tvector[b] = temp;\n}\n\nvoid quicksort(int vector[], int begin, int end)\n{\n\tif (begin >= end)\n\t\treturn;\n\n\tint i = begin;\n\tint j = end;\n\n\tint pivot = vector[(begin + end)/2];\n\t\n\twhile (vector[i] < pivot)\n\t\ti = i + 1;\n\n\twhile (vector[j] > pivot)\n\t\tj = j - 1;\n\n\tif (i <= j) {\n\t\tswap(vector, i, j);\n\t\ti++;\n\t\tj--;\n\t}\n\t\n\tquicksort(vector, begin, j);\n\tquicksort(vector, i, end);\n}\n\n\nint main()\n{\n\n\tint vector[] = {2, 7, 3, 8, 4, 9, 1, 0, -1};\n\tint size = 9;\t\n\n\tint i;\n\tfor (i = 0; i < size; i++){\n\t\tprintf(\"%d \", vector[i]);\n\t}\n\tprintf(\"\\n\");\n\n\tquicksort(vector, 0, size);\n\t\n\tfor (i = 0; i < size; i++){\n\t\tprintf(\"%d \", vector[i]);\n\t}\n\tprintf(\"\\n\");\n\n\treturn 0;\n}\n\n\n" }, { "path": "other-languages/sorting/quicksort/quicksort.php", "content": "= $chave;\n\t\t\t\t}))\n\t\t\t);\n}\n\n$vet = array(2, 7, 3, 8, 4, 9, 1, 0, -1);\n\n$tam = count($vet);\n\nfor ($i = 0; $i < $tam; $i++){\n\techo $vet[$i];\n}\n\necho \"\\n\";\n\n$vet_ordenado = quicksort($vet);\n\nfor ($i = 0; $i < $tam; $i++){\n\techo $vet_ordenado[$i];\n}\necho \"\\n\";\n?>" }, { "path": "other-languages/sorting/quicksort/quicksort.rb", "content": "\n=begin\n Quicksort\nAutor:\n ?\nColaborador:\n José Alberto O. Morais Filho (j.moraisg12@gmail.com)\nTipo:\n sorting\nDescrição:\n Um dos melhores algoritmos de ordenação existente. Recebe um vetor, e, recursivamente, aplica a função Partition nos\n subvetores. A função partition reposiciona os valores de um array de tal forma que todos os elementos da esquerda do\n pivô (ultimo elemento) sejam menores que ele e os da direita sejam maiores.\nComplexidade:\n O(n log n)\nDificuldade:\n médio\nReferências:\n [1] Cormem, Thomas H. Introduction to Algorithms, 3rd Edition. (Páginas 170-174)\n [2] http://en.wikipedia.org/wiki/Quicksort\n=end\n\n# Entrada:\n# array = um vetor a ser ordenado;\n# left = primeira posição do vetor (ou subvetor);\n# right = última posição do vetor (ou subvetor);\n# Saída:\n# o vetor ordenado\n\ndef partition(array, left, right)\n x = array[right]\n i = left - 1\n\n for j in left...right do\n if array[j] <= x then\n i += 1\n array[i], array[j] = array[j], array[i]\n end\n end\n\n array[i + 1], array[right] = array[right], array[i + 1]\n\n i + 1\n\nend\n\ndef quicksort(array, left, right)\n\n if left < right then\n q = partition(array, left, right)\n quicksort(array, left, q - 1)\n quicksort(array, q + 1, right)\n end\n\nend\n\n# Exemplos\na = [2, 8, 7, 1, 3, 5, 6, 4]\nb = [3, 1, 2, 6, 7, 4, 5]\n\nquicksort a, 0, 7\nprint a\n\nputs\n\nquicksort b, 0, 6\nprint b\n" }, { "path": "other-languages/sorting/selectionsort/selectionsort.cpp", "content": "/*\nSelection Sort\nAutor: \n ?\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo: \n sorting\nDescrição: \n É um algoritmo de ordenação que consiste em pesquisar o menor elemento\n e colocar na primeira posição, o segundo menor e colocar na segunda \n posição e assim sucessivamente, até que a sequência esteja ordenada.\n É uma excelente escolha quando há necessidade quando o custo de \n escrita é alto, pois ele realiza em torno de 2n operações de escrita. [2]\nComplexidade de tempo: \n O(n²)\nDificuldade: \n facil\nReferências:\n [1] http://en.wikipedia.org/wiki/Selection_sort\n [2] http://en.wikipedia.org/wiki/Selection_sort#Comparison_to_other_sorting_algorithms\n*/\n\n#include \n\nvoid selection_sort(int a[], int n) {\n int i, j, min;\n int temp;\n \n for (i = 0; i < n-1; i++) {\n min = i;\n // encontra o menor elemento\n for (j = i + 1; j < n; j++)\n if ( a[j] < a[min] )\n min = j;\n \n // insere o menor elemento encontrado na posição correta\n temp = a[i];\n a[i] = a[min];\n a[min] = temp;\n }\n}\n\nint main( ) {\n int a[] = {6, -2, 3, 5, 7, 4, 3};\n \n selection_sort(a, 7);\n \n for (int i = 0; i < 7; i++)\n std::cout << a[i] << \" \";\n \n return 0;\n}\n" }, { "path": "other-languages/sorting/selectionsort/selectionsort.php", "content": "\";\n\n?>" }, { "path": "other-languages/sorting/shellsort/shellsort.cpp", "content": "/*\nShell Sort\nAutor: \n Donald Shell\nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo: \n sorting\nDescrição: \n É um método que funciona repetidamente ordenando com insertion sort\n elementos com uma distância, inicialmente grande e que vai diminuindo de \n acordo com uma sequência, até que a distância é 1 e o vetor é finalmente\n ordenado.\nComplexidade de tempo: \n O(n^1.5)\nDificuldade: \n medio\nReferências:\n http://en.wikipedia.org/wiki/Shell_sort\n http://www.iti.fh-flensburg.de/lang/algorithmen/sortieren/shell/shellen.htm\n*/\n\n#include \n\nvoid shell_sort(int a[], int n) {\n int dist = 1; \n int i, j, temp;\n \n // Essa implementação do Shell Sort utiliza incrementos da forma 2^k - 1:\n // 1, 3, 7, 15, 31, 63, 127, ...\n \n // Aqui é determinado qual é o incremento inicial:\n // o maior incremento da forma 2^k - 1 que não é menor que n\n while ( 2*dist < n ) \n dist = 2*dist + 1;\n\n while ( dist > 0 ) {\n \n // Faz insertion sort com distancia dist (h-sort)\n for (i = dist; i < n; i++) {\n temp = a[i];\n \n for (j = i - dist; j >= 0 && temp < a[j]; j -= dist)\n a[j + dist] = a[j];\n \n a[j + dist] = temp;\n }\n \n // diminui a distância\n dist = dist / 2;\n }\n}\n\nint main( ) {\n int a[] = {6, -2, 3, 5, 7, 4, 3, 10, -1, 8};\n \n shell_sort(a, 10);\n \n for (int i = 0; i < 10; i++)\n std::cout << a[i] << \" \";\n \n return 0;\n}\n" }, { "path": "other-languages/sorting/stoogesort/stoogesort.cpp", "content": " \n/*\nStooge Sort\nAutores: \n Morris Howard, Lawrence Fine, Jerome Howard \nColaborador:\n Luiz Rodrigo (luizrodri.go@hotmail.com)\nTipo: \n sorting\nDescrição: \n É um algoritmo de ordenação recursivo bem de fácil implementação: verifica \n se o primeiro elemento é maior que o último, ordena os 2 primeiros terços \n do vetor, ordena os 2 ultimos e ordena os dois primeiros novamente. Apesar \n de elegante, é um algoritmo bem lento (pior até que o bubble sort).\nComplexidade: \n O(n^2.701)\nDificuldade: \n facil\nReferências:\n [1] http://en.wikipedia.org/wiki/Stooge_sort\n*/\n\n#include \n\nvoid stooge_sort(int a[], int left, int right) {\n if ( a[left] > a[right] ) {\n int temp = a[left];\n a[left] = a[right];\n a[right] = temp;\n }\n \n if ( right-left > 1 ) {\n int k = (right-left+1)/3;\n stooge_sort(a, left, right-k);\n stooge_sort(a, left+k, right);\n stooge_sort(a, left, right-k);\n }\n}\n\nint main( ) {\n int a[] = {6, -2, 3, 5, 7, 4, 10, 3};\n \n stooge_sort(a, 0, 7);\n \n for (int i = 0; i < 8; i++)\n std::cout << a[i] << \" \";\n \n return 0;\n}\n" } ]