Ir para o conteúdo

Pesquisar na Comunidade

A mostrar resultados para tags ''algoritmos''.



Mais opções de pesquisa

  • Pesquisa por Tags

    Introduza as tags separadas por vírgulas.
  • Pesquisar por Autor

Tipo de Conteúdo


Fórum

  • Bem-vindos ao Portugal-a-Programar
    • Sugestões, Críticas ou Dúvidas relativas ao P@P
    • Acerca do P@P
  • Comunidade a Trabalhar
    • Wiki P@P
    • Apresentação de Projectos de Programação
    • Downloads
  • Revista PROGRAMAR
    • Revista PROGRAMAR
  • Desenvolvimento Geral
    • C
    • C++
    • Java
    • Haskell
    • Pascal
    • Python
    • Bases de Dados
    • Visual Basic Clássico
    • Visual Basic for Applications (VBA)
    • Dispositivos Móveis
    • Outras Linguagens
  • Desenvolvimento Orientado para Web
    • PHP
    • HTML
    • CSS
    • Javascript
    • Outras Linguagens de WebDevelopment
    • Desenvolvimento Web
  • Desenvolvimento .NET
    • C#
    • Visual Basic .NET
    • ASP.NET
    • WPF & SilverLight
  • Software e Sistemas Operativos
    • Software de Produtividade
    • Sistemas Operativos
    • SharePoint
    • Apresentação de Software
  • Informática Extra-Programação
    • Interfaces Visuais
    • Computação Gráfica
    • Algoritmia e Lógica
    • Segurança e Redes
    • Hardware
    • Electrónica
    • Automação Industrial
    • Dúvidas e Discussão de Programação
    • Notícias de Tecnologia
  • Outras Áreas
    • Matemática
    • Dúvidas Gerais
    • Discussão Geral
    • Eventos
    • Anúncios de Emprego
    • Tutoriais
    • Snippets / Armazém de Código
  • Arquivo Morto
    • Projectos Descontinuados
    • System Empires

Blogs

  • Blog dos Moderadores
  • Eventos
  • Notícias de Tecnologia
  • Blog do Staff
  • Revista PROGRAMAR
  • Projectos
  • Wiki

Categorias

  • Revista PROGRAMAR
  • Tutoriais
  • Textos Académicos
  • Exercícios Académicos
    • Exercícios c/ Solução
    • Exercícios s/ Solução
  • Bibliotecas e Aplicações
  • Outros

Procurar resultados em...

Pesquisar conteúdos que contêm...


Data de Publicação

  • Início

    Fim


Última Actualização

  • Início

    Fim


Filtrar por número de...

37 resultados

  1. Ruan_sóstenes_muniz_braga

    como calcular o século em java?

    olá pessoal, estou estudando programação há três meses, mais estou com alguns problemas. Preciso criar um algoritmo que calcule o século em que um ano se encontra. Já pesquisei mais ñ encontrei nada que possa me ajudar. Gostaria de saber como vocês (os mais experientes) resolveriam esse problema. desde já agradeço.
  2. AprendizZ

    Jogo de Damas - melhor algoritmo

    Boas. Num trabalho académico estou a programar em java um jogo de damas. Tenho por base uma outra implementação (Ashish Prasad/Apurv) que usa um algoritmo Minimax (ou MinMax ou MM) melhorado com Alpha–beta pruning. No entanto quando coloco o computador a jogar contra ele mesmo (que usam ambos os mesmos algoritmos) o jogo entra em "loop" sem encontrar um vencedor. Experimentei fazer com que a nível de Alpha-beta a melhor jogada fosse aleatória, mas não dá. Será possível implementar um algoritmo/estratégia mais eficiente, num dos jogadores (computador com Minimax vs computador com algoritmo/estratégia que procuro) de forma a obter melhores probabilidade de ganhar? O código (dos jogadores, ambos como computador) em que me estou a basear é o seguinte: package checkers; import java.util.Vector; /** * * @author apurv */ public class Robot { static Oracle oracle = new Oracle(); static int MAX_DEPTH = 6; public static void makeNextWhiteMoves(){ Vector<Move> resultantMoveSeq = new Vector<Move>(); alphaBeta(Game.board, Player.white, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, resultantMoveSeq); //Apply the move to the game board. for(Move m:resultantMoveSeq){ Game.board.genericMakeWhiteMove(m); } System.out.print("Robot's Move was "); UserInteractions.DisplayMoveSeq(resultantMoveSeq); System.out.println(); } public static void makeNextBlackMoves(){ Vector<Move> resultantMoveSeq = new Vector<Move>(); alphaBeta(Game.board, Player.black, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, resultantMoveSeq); //Apply the move to the game board. for(Move m:resultantMoveSeq){ Game.board.genericMakeBlackMove(m); } System.out.print("Robot's Move was "); UserInteractions.DisplayMoveSeq(resultantMoveSeq); System.out.println(); } /** * White represents the maximizing player, he/she wants to maximize the value of the board. * Black is the minimizing player, he/she wants to minimize the value of the board. * * alpha represents the maximum value that the max player is assured of, initially -inf. * beta represents the minimum value that the min player is assured of, initially +inf. * * if(alpha>beta) break * * */ private static int alphaBeta(Board board, Player player, int depth, int alpha, int beta, Vector<Move> resultMoveSeq){ if(!canExploreFurther(board, player, depth)){ int value = oracle.evaluateBoard(board, player); return value; } Vector<Vector<Move>> possibleMoveSeq = expandMoves(board, player); Vector<Board> possibleBoardConf = getPossibleBoardConf(board, possibleMoveSeq, player); Vector<Move> bestMoveSeq = null; if(player == Player.white){ for(int i=0; i<possibleBoardConf.size(); i++){ Board b = possibleBoardConf.get(i); Vector<Move> moveSeq = possibleMoveSeq.get(i); int value = alphaBeta(b, Player.black, depth+1, alpha, beta, resultMoveSeq); if(value > alpha){ alpha = value; bestMoveSeq = moveSeq; } if(alpha>beta){ break; } } //If the depth is 0, copy the bestMoveSeq in the result move seq. if(depth == 0 && bestMoveSeq!=null){ resultMoveSeq.addAll(bestMoveSeq); } return alpha; }else{ assert(player == Player.black); for(int i=0; i<possibleBoardConf.size(); i++){ Board b = possibleBoardConf.get(i); Vector<Move> moveSeq = possibleMoveSeq.get(i); int value = alphaBeta(b, Player.white, depth+1, alpha, beta, resultMoveSeq); if(value < beta){ bestMoveSeq = moveSeq; beta = value; } if(alpha>beta){ break; } } //If the depth is 0, copy the bestMoveSeq in the result move seq. if(depth == 0 && bestMoveSeq!=null){ resultMoveSeq.addAll(bestMoveSeq); } return beta; } } public static Vector<Vector<Move>> expandMoves(Board board, Player player){ Vector<Vector<Move>> outerVector = new Vector<Vector<Move>>(); if(player == Player.black){ Vector<Move> moves = null; moves = Black.CalculateAllForcedMovesForBlack(board); if(moves.isEmpty()){ moves = Black.CalculateAllNonForcedMovesForBlack(board); for(Move m:moves){ Vector<Move> innerVector = new Vector<Move>(); innerVector.add(m); outerVector.add(innerVector); } }else{ for(Move m:moves){ int r = m.finalRow; int c = m.finalCol; Vector<Move> innerVector = new Vector<Move>(); innerVector.add(m); Board boardCopy = board.duplicate(); boardCopy.genericMakeBlackMove(m); expandMoveRecursivelyForBlack(boardCopy, outerVector, innerVector, r, c); innerVector.remove(m); } } }else if(player == Player.white){ Vector<Move> moves = null; moves = White.CalculateAllForcedMovesForWhite(board); if(moves.isEmpty()){ moves = White.CalculateAllNonForcedMovesForWhite(board); for(Move m:moves){ Vector<Move> innerVector = new Vector<Move>(); innerVector.add(m); outerVector.add(innerVector); } }else{ for(Move m:moves){ int r = m.finalRow; int c = m.finalCol; Vector<Move> innerVector = new Vector<Move>(); innerVector.add(m); Board boardCopy = board.duplicate(); boardCopy.genericMakeWhiteMove(m); expandMoveRecursivelyForWhite(boardCopy, outerVector, innerVector, r, c); innerVector.remove(m); } } } return outerVector; } private static void expandMoveRecursivelyForWhite(Board board, Vector<Vector<Move>> outerVector, Vector<Move> innerVector, int r, int c){ Vector<Move> forcedMoves = White.ObtainForcedMovesForWhite(r, c, board); if(forcedMoves.isEmpty()){ Vector<Move> innerCopy = (Vector<Move>)innerVector.clone(); outerVector.add(innerCopy); return; }else{ for(Move m:forcedMoves){ Board boardCopy = board.duplicate(); boardCopy.genericMakeWhiteMove(m); innerVector.add(m); expandMoveRecursivelyForWhite(boardCopy, outerVector, innerVector, m.finalRow, m.finalCol); innerVector.remove(m); } } } private static void expandMoveRecursivelyForBlack(Board board, Vector<Vector<Move>> outerVector, Vector<Move> innerVector, int r, int c){ Vector<Move> forcedMoves = Black.ObtainForcedMovesForBlack(r, c, board); if(forcedMoves.isEmpty()){ Vector<Move> innerCopy = (Vector<Move>)innerVector.clone(); outerVector.add(innerCopy); return; }else{ for(Move m:forcedMoves){ Board boardCopy = board.duplicate(); boardCopy.genericMakeBlackMove(m); innerVector.add(m); expandMoveRecursivelyForBlack(boardCopy, outerVector, innerVector, m.finalRow, m.finalCol); innerVector.remove(m); } } } private static boolean canExploreFurther(Board board, Player player, int depth){ boolean res = true; if(board.CheckGameComplete() || board.CheckGameDraw(player)){ res = false; } if(depth == MAX_DEPTH){ res = false; } return res; } public static Vector<Board> getPossibleBoardConf(Board board, Vector<Vector<Move>> possibleMoveSeq, Player player){ Vector<Board> possibleBoardConf= new Vector<Board>(); for(Vector<Move> moveSeq:possibleMoveSeq){ Board boardCopy = board.duplicate(); for(Move move:moveSeq){ if(player == Player.black){ boardCopy.genericMakeBlackMove(move); }else{ boardCopy.genericMakeWhiteMove(move); } } possibleBoardConf.add(boardCopy); //System.out.println(); } return possibleBoardConf; } ///////////////////////DEBUGGING PURPOSES///////////////////////////////////////////////////////// public static void main(String[] args){ // // CellEntry[][] cell = new CellEntry[][]{ //{CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid}, //{CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white}, //{CellEntry.empty, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.empty, CellEntry.inValid}, //{CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.empty}, //{CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid}, //{CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black}, //{CellEntry.black,CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid}, //{CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black} // // }; // // Board board = new Board(cell); // // Vector<Vector<Move>> outerVector = expandMoves(board, Player.black); // // board.Display(); // // for(Vector<Move> innerVector:outerVector){ // for(Move move:innerVector){ // move.display(); // System.out.print(", "); // } // System.out.println(); // } //===================================================Checking Game Draw=============================== // CellEntry[][] cell = new CellEntry[][]{ //{CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid}, //{CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black}, //{CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid}, //{CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty}, //{CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid}, //{CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white}, //{CellEntry.white,CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid}, //{CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white} // }; // // Board board = new Board(cell); // System.out.println(board.CheckGameDraw(Player.white)); //==================================================================================================== // //Board board = new Board(); // Vector<Move> resultantMoveSeq = new Vector<Move>(); // // alphaBeta(board, Player.black, 0, Float.MIN_VALUE, Float.MAX_VALUE, resultantMoveSeq); // board.Display(); // displayMovesInVector(resultantMoveSeq); // System.out.println(resultantMoveSeq.size()); //testCase1(); //testCase2(); testCase3(); } // For debugging private static void displayMovesInVector(Vector<Move> v){ for(Move m:v){ m.display(); System.out.print(", "); } System.out.println(); } private static void testCase1(){ CellEntry[][] cell = new CellEntry[][]{ {CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid}, {CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.white}, {CellEntry.white, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid}, {CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.empty}, {CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid}, {CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty}, {CellEntry.empty,CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid}, {CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black} }; System.out.println(Float.MIN_VALUE); if(-600>Integer.MIN_VALUE){ System.out.println("Lele maje");/////// } Board board = new Board(cell); board.whitePieces = 7; board.blackPieces = 7; Vector<Move> resultantMoveSeq = new Vector<Move>(); // alphaBeta(board, Player.black, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, resultantMoveSeq); board.Display(); displayMovesInVector(resultantMoveSeq); } private static void testCase2(){ CellEntry[][] cell = new CellEntry[][]{ {CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.white, CellEntry.inValid}, {CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white}, {CellEntry.black, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid}, {CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.empty}, {CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.empty, CellEntry.inValid}, {CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.black}, {CellEntry.empty,CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid}, {CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black} }; Board board = new Board(cell); board.whitePieces = 5; board.blackPieces = 6; Board newBoard = board.duplicate(); System.out.println(newBoard.CheckGameComplete()); Vector<Move> resultantMoveSeq = new Vector<Move>(); // alphaBeta(board, Player.black, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, resultantMoveSeq); board.Display(); displayMovesInVector(resultantMoveSeq); //Apply the move to the game board. for(Move m:resultantMoveSeq){ board.genericMakeWhiteMove(m); } resultantMoveSeq.clear(); alphaBeta(board, Player.white, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, resultantMoveSeq); board.Display(); displayMovesInVector(resultantMoveSeq); } private static void testCase3(){ CellEntry[][] cell = new CellEntry[][]{ {CellEntry.empty, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid}, {CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty}, {CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.white, CellEntry.inValid, CellEntry.empty, CellEntry.inValid}, {CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty}, {CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid}, {CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.empty}, {CellEntry.empty,CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid}, {CellEntry.inValid, CellEntry.empty, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black, CellEntry.inValid, CellEntry.black} }; Board board = new Board(cell); board.whitePieces = 5; board.blackPieces = 6; Vector<Move> resultantMoveSeq = new Vector<Move>(); // alphaBeta(board, Player.black, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, resultantMoveSeq); board.Display(); displayMovesInVector(resultantMoveSeq); } } Desde já um muito obrigado pela ajuda.
  3. fran.aubry

    UCL ACM-ICPC Training Camp

    Olá a todos. Sou ex-participante em Portugal e agora estou a fazer doutouramento na Bélgica. Sou treinador das equipas para o NWERC e já por mais de 3 anos ganhamos medalhas. Este ano vamos organisar um campo de treino aqui na Bélgica: https://sites.uclouvain.be/acm-icpc18/index.html
  4. Boa noite galera, estou estudando sobre pseudocodigos, recentemente e me surgiram exercicios nos quais tive problemas; programa calc var n,conta:inteiro inicio n <- 8 conta <- 2 repita conta <- conta + ( n – 1 ) n <- n – 1 até que n = 0 escreva conta fim. var x : inteiro inicio x <- 11 se ( x < > 1 0) se ( ( x > 15 ) OU ( x <= 20 ) ) x <- x + 2 senão x <- x – 4 fim_se fim_se se ( x MOD 4 >= 2 ) x <- x + 5 senão x <- x – 3 fim_se escreva “ x = “, x fim Conseguem me ajudar/explicar qual seria o resultado final de ambos os códigos?
  5. Versão 2005/2006

    954 downloads

    Slides de curso de Algoritmos e Estruturas de Dados. Instituto Superior Técnico Departamento de Engenharia Electrotécnica e de Computadores Algoritmos e Estruturas de Dados Autor: Professor Luís Miguel Silveira Conteúdo Motivação - Problema da Conectividade Estruturas de Dados Análise de Algoritmos e Complexidade Algoritmos de Ordenação Tabelas de Dispersão Árvores Filas com prioridade Grafos
  6. Rui Carlos

    Algoritmia e Estruturas de Dados (ISEP)

    Versão Fevereiro 2006

    1541 downloads

    Instituto Superior de Engenharia do Porto Departamento de Engenharia Informática Autor: Professor Jorge Santos Resumo Estes apontamentos têm como objectivo principal apoiar os leitores que pretendam aprender programação de computadores Os conteúdos propostos têm como objectivo fornecer bases sólidas de metodologias de programação que auxiliem a compreensão de programas computacionais simples, a sua adaptação e desenvolvimento de novas aplicações, e estimular a capacidade dos leitores para: analisar e resolver problemas de programação. A estrutura destes apontamentos foi definida de acordo com a abordagem de aprender-por-exemplo, pelo que, os conceitos são apenas introduzidos de acordo com a necessidade de explicar a resolução de um determinado algoritmo. Neste manual introduzem-se as bases da algoritmia de acordo com o paradigma da programação estruturada. Em cada secção é apresentada um pequena introdução teórica sobre o tópico em destaque, apresentados problemas e propostas soluções para os mesmos, adicionalmente são propostos exercícios para resolução. Na codificação/apresentação das soluções é geralmente Pseudo-Código e/ou Fluxogramas. Este documento compila exercícios de vários anos de ensino de muitos docentes do departamento nos quais me incluo. Ao longo do manual poderão ser encontrados exemplos e exercícios propostos pelos docentes nas disciplinas de Algoritmia e Programação, Linguagens de Programação I do curso de Engenharia Informática do Departamento de Engenharia Informática (DEI), bem como de Programação I e Programação II do curso Engenharia Electrotécnica do Departamento de Engenharia Electrotécnica (DEE), ambos do ISEP.
  7. Versão 2010/2011

    6690 downloads

    Slides de curso de Algoritmos e Estruturas de Dados. Universidade do Porto Faculdade de Engenharia Autores: Professora Ana Paula Rocha, Professor Rosaldo Rossetti, Professor António Castro Conteúdo Programação Orientada por Objectos em C++ Sobrecarga de Operadores em C++ Herança em C++ Templates em C++ Excepções em C++ Introdução ao UML e Ferramentas para C++ Análise de Complexidade de Algoritmos Vectores: Algoritmos de Pesquisa Vectores: Algoritmos de Ordenação Listas Filas de prioridade Árvores Tabelas de dispersão Filas de prioridade Árvores AVL Árvores “Splay” Árvores B
  8. Versão

    2494 downloads

    Instituto Politécnico de Viana do Castelo Escola Superior de Técnologia e Gestão Algoritmos e Estruturas de Dados Autores: Professor Dr. Salvado Lima, Professor Ricardo Castro Conteúdo Algoritmos Linguagem de Programação C Operadores / Estruturas de Controlo de Fluxo Apotadores / Arrays
  9. jpaulino

    Modelação de Dados (IPS - ESCE)

    Versão

    8907 downloads

    Instituto Politécnico de Setúbal Escola Superior de Ciências Empresariais Autor: Professor José Gaivéo (2009-2010) Conteúdo: Globalização e Sociedade de Informação Teoria de Sistemas Informação Gestão dos Sistemas de Informação e das TIC Planeamento e Desenvolvimento dos Sistemas de Informação Especificação de Necessidades e Requisitos Algoritmos Modelação Modelação de Processos Modelação de Dados Modelação de Processos vs Modelação de Dados Abordagem Moderna à Modelação de Dados Outras Abordagem à Modelação de Dados Ferramentas de Modelação de Dados Desenvolvimento de Sistemas
  10. Versão 2004/2005

    274 downloads

    Conjunto de exercícios sobre implementação de algoritmos e estruturas de dados, usando Pascal. Universidade de Aveiro Departamento de Matemática Autor: Professora Rosália Rodrigues
  11. crislanio_macedo

    Ordenador QuickSort com Threads

    Versão N/D

    93 downloads

    Implementação de ordenação usando multi-threading.
  12. Luís00

    Corrigir função c#

    Considerar a seguinte função em C#: public static bool DoThings(int[] x, int j, out int i) { i = 0; for (int i = 1; i < x.length(); ++i) if (x == j) ++i return i > 0; } Corrija a função de modo a que funcione (tenha um comportamento útil). Descreva o funcionamento implementado (para que serve a função).
  13. Luís00

    Class Data C#

    Olá pessoal, estou precisando da vossa ajuda para resolver o seguinte problema: Considere a necessidade de representar uma data (dia, mês, ano). Defina uma classe que permita: definir uma nova data; Garantir que a data é válida (número de dias válido para o mês em causa, e mês válido); Funcione corretamente para anos bissextos. Um ano é bissexto se: ano % 4 == 0 && (ano % 100 != 0 || ano % 400 == 0) Permita o uso de propriedades para alterar dia, mês e ano (e obter respetivos valores); Implemente um método para a sua representação numa string devidamente formatada, Não é permitido a utilização da class DateTime.
  14. Fidel Carlos Tembe

    Algoritmo para média

    Considere o cálculo da media de quatro algarismos. Apresente: a) O algoritmo simples em Fluxograma; b) O algoritmo simples em Pseudo-código;
  15. Olá, estou escrevendo para contar e compartilhar com um projeto que eu só percebi, é chamado de pseudo-código, é uma aplicação Android, destinado a estudantes que frequentam os primeiros ciclos e fazer o curso de algoritmos e programação, eu ter tomado esse curso ea ele precisa fazer uma ferramenta para testar os nossos algoritmos, especialmente a partir do celular no momento em que é essencial para cada aluno, como nem todos andar com um laptop na mochila. I compartilhar o link do meu projeto: https : // play.google.com /store/apps/details?id=pe.diegoveloper.pseudocode Ele é baseado no pseudocódigo ferramenta para PC: PSeInt (estritamente) http : // pseint. sourceforge . net/ A aplicação suporta Inglês e Espanhol, se quisessem traduzi-lo para necessidade Português de sua ajuda, você acha? lembranças
  16. telmolourenço

    Algoritmo verificaçao respostas

    Boa tarde, estou com um problema no desenvolvimento de um algoritmo e agradecia a vossa ajuda, caso seja possivel. Tenho um grupo de 20 pessoas, que respondem a um questionario de escolhas multiplas e a funçao do algoritmo é fazer a comparaçao entre todos os questionarios e devolver as que têm as respostas iguais. Alguem que consegue ajudar? Obrigado
  17. cataninja

    Função do seno

    Olá pessoal, será que me podem ajudar com um problema? Tenho de escrever o algoritmo disto: O seno de x pode ser calculado usando o desenvolvimento em série de Taylor Escreva e teste uma funçao que determine o seno de um angulo x (introduzido pelo utilizador em radianos), usando este desenvolvimento em série, até um termo em que a diferença para o termo seguinte tenha um valor absoluto abaixo de uma tolerância (especificada pelo utilizador). Sugestão: utilize uma funçao para calcular o fatorial de um número. P.S.: se vos der mais jeito podem fazer o programa e eu tento fazer o algoritmo a partir daí
  18. crislanio_macedo

    Ordenador QuickSort com Threads

    Ordenador QuickSort com Threads Ver Ficheiro Implementação de ordenação usando multi-threading. Submetido por crislanio_macedo Submetido em 14-06-2015 Categoria Bibliotecas e Aplicações Licença Website https://github.com/crislanio/OrdenadorQuickSortComThreads Submetido pelo Autor? Sim
  19. angelicous

    Pesquisar numa tabela hash polinomial

    Boas eu tenho uma tabela hash polinomial, que me codifica palavras que têm 2 letras e 2 números. Por exemplo o formato que uso para a codificação é esta Onde k1 é a primeira letra, k2 a segunda ... e A é um número primo, que no meu caso é 11. Agora eu tenho a tabela com as palavras, sem qualquer problema a pesquisar palavras completas... O meu problema é, eu quero fazer uma função, onde é fornecida a primeira letra, e eu quero que ele me retorne todas as palavras na tabela que começam com essa letra. Não conhecendo a ordem da tabela visto que a hash gera as posições aleatóriamente, como é que posso fazer isto, sem ter que correr a tabela toda de ponta a ponta?
  20. Boas pessoal... Sou novato aqui no forum e no mundo da programação. Estou com um sério problema e não sei como começar! Portanto, pretendia implementar o algoritmo Ricart-Agrawala em Java, usando JGroup como mecanismo de comunicação, devendo o sistema ser constituído apenas por um módulo (ou peer). Cumps
  21. amigos preciso criar uma calculado em binário com as 4 operações básicas, em c++ e apresentar o algorítimo alguem me da alguma dica por favor
  22. Joao10

    Computador escolhe entre duas palavras

    Bom dia, Estou a fazer o jogo do par ou impar no Python, e queria que o computador escolhe-se aleatoriamente se quer par ou impar para jogar. Para o computador gerar um numero aleatório para jogar utilizei a função random.randint, e agora queria que o computador escolha se quer ficar com o par ou com o impar. Mas não estou a conseguir fazer, alguém me consegue ajudar sff? Obrigado
  23. miguel__1

    [Resolvido] Jogo do par ou impar

    Boas, tenho um trabalho para realizar na disciplina de algoritmos que é o jogo do par ou impar, mas eu queria fazer o jogo da maneira a que quem ganhar seja a melhor de 3 vitorias ou 5 vitorias, mas o programa ta a dar-me erro em quem ganha, os ciclos nao estao a funcionar bem e esta a aparecer sempre a vitoria dos dois :S nome = raw_input ("Introdua um nome: ") import random computador = random.randint (1,10) #while True: utilizador = raw_input ("Quer par ou impar: ") if utilizador == "par" or utilizador == "impar" and utilizador != "PAR" or utilizador != "IMPAR": par = utilizador impar = computador elif utilizador == "impar": impar == utilizador par == computador else: utilizador != "par" and utilizador != "impar" utilizador != "PAR" and utilizador != "IMPAR" print "ERRO" numero = input ("Digite o numero: ") computador = random.randint (1,10) print "O computador escolheu: ",computador print "O ",nome," escolheu: ",numero total = numero + computador print "O resultado é: ",total if total%2==0: print "O Resultado é: Par" else: print "O Resultado é: Impar" if utilizador == "par": print "O ",nome, " escolheu o numero ",numero," e ganhou o ",nome elif utilizador == "impar": print "O ",nome, " escolheu o numero ",numero," e ganhou o ",nome else: print "Ganhou o Computador" #else: # print "Ganhou o Computador!" # if utilizador == "impar": # print "O ",nome, " escolheu o numero ",numero," e ganhou o ",nome # else: # print "O computador escolheu o numero ",computador," e ganhou o Computador!" mas o programa ainda nao tem a parte de quem ganha o jogo, a melhor de 3 ou 5, feita.
  24. thoga31

    Reverse Polish Notation

    Isto é só mesmo para meter o pessoal a tirar a areia dos pirolitos e movimentar um pouco mais o quadro Anyway, é sempre um desafio com um carácter útil. Título: Reverse Polish Notation (RPN) Descrição: Como muitos de vós deveis saber, esta é uma das formas de representar expressões matemáticas para depois serem calculadas. Tem uma estrutura postfix em vez da natural (commumente designada por estrutura infix) e que não tem parêntesis, isto porque, regra geral, estas expressões RPN são geradas a partir das expressões "naturais" com recurso a parsers (coisas bonitas que não nos interessam para aqui), de forma a que a expressão seja facilmente avaliada e calculada directamente da esquerda para a direita. A Wikipédia explica o resto para quem não está familiarizado. Objectivo: Criar uma função que receba uma expressão RPN e devolva o respectivo resultado. A expressão só pode conter as principais 5 operações (+-*/^) e não mais nenhuma função (logaritmo, por exemplo). Restrições: Deve haver uma gestão de erros, a qual fica a vosso critério. Exemplos I/O: >> 3 4 + 7 >> 5 1 2 + 4 * + 3 - 14 >> 2 5 ^ 1 + 33
  25. Slides de Algoritmos e Estruturas de Dados (IST) Ver Ficheiro Slides de curso de Algoritmos e Estruturas de Dados. Instituto Superior Técnico Departamento de Engenharia Electrotécnica e de Computadores Algoritmos e Estruturas de Dados Autor: Professor Luís Miguel Silveira Conteúdo Motivação - Problema da Conectividade Estruturas de Dados Análise de Algoritmos e Complexidade Algoritmos de Ordenação Tabelas de Dispersão Árvores Filas com prioridade Grafos Submetido por Rui Carlos Submetido em 02-02-2013 Categoria Textos Académicos Licença Website http://algos.inesc-id.pt/aed06/ Submetido pelo Autor? Não
×

Aviso Sobre Cookies

Ao usar este site você aceita os nossos Termos de Uso e Política de Privacidade. Este site usa cookies para disponibilizar funcionalidades personalizadas. Para mais informações visite esta página.