Search the Community

O sistema de numeração romana (ou números romanos) desenvolveu-se na Roma Antiga e utilizou-se em todo o seu Império. Neste sistema as cifras escrevem-se com determinadas letras, que representam os números. As letras são sempre maiúsculas, já que no alfabeto romano não existem as minúsculas, as letras são I, V, X, L, C, D e M. Sua tarefa é desenvolver um programa que converta números romanos formato arábico. As regras para a formação dos números romanos são apresentadas a seguir. Cada letra corresponde a um determinado valor: I = 1 V = 5 X = 10 L = 50 C = 100 D = 500 M = 1000. Agrupando as letras acima, podemos representar os números de acordo com um conjunto de regras: Com exceção de V, L e D, os outros numerais podem se repetir no máximo três vezes: III = 3 XXX = 30 CCC = 300 MMM = 3000 Quando escritos à direita de numerais maiores, I, X e C somam-se aos valores dos primeiros: VIII = 5 + 1 + 1 + 1 = 8 LXII = 50 + 10 + 1 + 1 = 62 CLVIII = 158 MCXX = 1000 + 100 + 10 + 10 = 1120 Mas se os numerais I, X e C estiverem à esquerda dos maiores, seus valores são subtraídos como, por exemplo, em: IV = 5 - 1 = 4 IX = 10 - 1 = 9 XC = 100 - 10 = 90 Acho que sei como finalmente fazer primeiramente eu pegaria o valor em romano digitado, pegaria o tamanho da letra valor atribuído seria n tamanho da letra e desse tamanho da letra tiraria n-1, depois tentaria dividir a letra, não sei o comando no VisualG para separar as letras e criaria um variável para armazenar o separamento dessas letras nesse caso separador criaria outra variável nesse caso s e receberia zero depois faria um para onde i =0 e i tem que ser menor que o tamanho da letra nessa e iria somando por +1 depois abriria um se verificando se a divisão da letras separador = "M" então s= s+1000 e dentro desse se abriria outro se e se se separador[i-1]= "C" então s= s-200, terminaria esse se depois abriria outro se verificando se separador = "D" então s=s+500 e dentro abriria outro se e se separador[i-1] = "C" então s=s-200 depois fecharia esse se e abriria outro se separador = "C" então s=s+100 e dentro desse se abriria outro se se separador[i-1] = "X" e então s=s-20 depois terminaria esse se e abriria outro se, se separador = "L" então s=s+50 dentro abriria outro se, se separador[i-1] = "X" então s=s-20 depois terminaria esse se e abriria outro se, se separador="X" então s=s+10 abriria outro se, se separador[i-1] = "I" então s=s-2 depois fecharia esse se depois abriria outro se, se separador="V" então s=s+5 e dentro desse se abriria outro se, se separador[i-1] = "I" então s=s-2 fecharia esse se depois abriria outro se se separador = "I" então s=s+1 depois daria um escreval(s) O problema está na hora de separar as letras qual o comando no VisualG para separar letra ou não tem? O comando copia é útil somente se separar letra por letra porém falha na hora, por exemplo de copiar um número romano, eu eu tenho que já passar esse comando com parâmetros já pré-deficinidos copie desta casa até esta casa (romano;1;2), que no não teria como colocar todos os parâmetros para todos os números de 1 a 3999 Var // Seção de Declarações das variáveis vetromano:vetor[1..9] de caractere romano:caractere i:inteiro m,c,d,u:caractere soma:inteiro Inicio // Seção de Comandos, procedimento, funções, operadores, etc... escreval("Digite um número em romano para ser convertido em arábico") escreval("menor que 4000 e maior que 0") leia(romano) m <- copia(romano;1;2) c <- copia(romano;3;2) d <- copia(romano;5;2) u <- copia(romano;7;2) para i de 1 ate Compr(romano) faca se (m = "M") entao soma<-soma+1000 se(m-1) entao soma<-soma-200 fimse fimse escreval(soma) fimpara Fimalgoritmo Sou brasileiro como puderam perceber, você conhecem a linguagem VisualG?

Olá a todos, inicio este tópico porque preciso de ajuda sobre qual o algoritmo que é usado para calcular o digito de verificação (nono digito) do número de utente do SNS. Segundo a legislação (Portaria nº 981/95) link: https://dre.pt/web/guest/pesquisa/-/search/477871/details/normal?q=981%2F95 usa a Norma ISO 7064 (MOD 11-2). Pelas minhas pesquisas, e resumindo o algoritmo, o mod 11, multiplica : 1 2 3 4 5 6 7 8 9 ---- numero ficticio do SNS por 9 8 7 6 5 4 3 2 - ----- factor de multiplicação depois soma tudo e divide por 11 (Mod11), com base no resto da divisão faz 11-resto e o numero será o digito de verificação (sendo que se for 11 ou 10 aplica-se 0 Isto aplicado ao NIF funciona bem. Mas para o numero do SNS não. Alguém aqui no fórum me pode ajudar com isto?

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.