Pesquisar na Comunidade

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.

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.

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

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?

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).

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.

Considere o cálculo da media de quatro algarismos. Apresente: a) O algoritmo simples em Fluxograma; b) O algoritmo simples em Pseudo-código;

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

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

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í

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

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?

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

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

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

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.

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

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