Lucas LC
-
Posts
48 -
Cadastrado em
-
Última visita
Tipo de conteúdo
Artigos
Selos
Fabricantes
Livros
Cursos
Análises
Fórum
posts postados por Lucas LC
-
-
Pessoal, boa noite!
Preciso de ajuda, estou querendo criar um banco de dados, usando Java principalmente, já fiz um banco de dados na mão mesmo, criei uma árvore B em arquivo e adicionava alguns dados nessa árvore B e excluía, consultava etc..., mas quero melhorar e criar um de verdade, usando o SQL ou MYSQL, que são SGBD, alguém conhece um artigo sobre isso, ou pode me orientar com algumas dicas.
-
Em 04/08/2021 às 12:38, rjjj disse:
Espero ter ajudado
.
Boaa, ajudou sim, obrigado cara.
-
Bom dia!
Estou fazendo um programa de agendamento de reuniões e não posso usar operações tipo: (11/02/2020 < 11/03/2020) porque são Strings, queria saber se tem algum método ou forma de saber se uma data for menor q a outra ou maior e então retornar que não vai ter reunião neste dia.
E também, estou trabalhando com um tipo de lista que é o TreeMap e quero encontrar o horário e data que mais se repetiu nessa lista:
private TreeMap<String, LocalDateTime[]> disponibilidades = new TreeMap<>();
LocalDateTime - quarta todas as horas e datas preenchidas pelos participantes;
String - Identificação do participante.
-
Em 17/07/2021 às 21:20, AdrianoSiqueira disse:
O pacote dessa classe não parece ser nativa do Java. Você adicionou alguma biblioteca externa? Se sim, qual?
Na verdade, nem sabia que eu estava usando classes q não são nativa do Java.
Em 17/07/2021 às 21:39, Antov disse:Ah beleza, obrigado!
-
Boa tarde!
Alguém conhece a criptografia no java ? Estou tentando usar a classe BasicPasswordEncryptor, mas parece que não existe.
package org.jasypt.util.password; import org.jasypt.util.password.BasicPasswordEncryptor; class Main { public static void main(String[] args) { BasicPasswordEncryptor encryptor = new BasicPasswordEncrypto(); String senhaCriptografada = encryptor.encryptPassword("senha123"); System.out.println(senhaCriptografada); } }
-
1
-
-
Em 08/01/2021 às 12:27, AdrianoSiqueira disse:
Seria bom armazenar os resultados em uma lista, depois é só pegar o que tem o menor valor
Obrigado Adriano, acho que consegui terminar.
Obrigado pela ajuda.
-
1
-
-
8 horas atrás, AdrianoSiqueira disse:
Procure sobre a interface Cloneable, ela é responsável por abstrair esse tipo de tarefa.
Consegui fazer meu explorador percorrer todo o labirinto e imprimir todos os caminhos possíveis, agora preciso separar entre aquele mais curto e mais longo.
Esse tabuleiro tem apenas 3 caminhos possíveis:
(x,y): (6, 2)
(x,y): (5, 2)
(x,y): (4, 2)
(x,y): (3, 2)
(x,y): (2, 2)
(x,y): (1, 2)
(x,y): (0, 2)
Tamanhos 7Destino Encontrado!!
(x,y): (6, 2)
(x,y): (6, 1)
(x,y): (6, 0)
(x,y): (5, 0)
(x,y): (4, 0)
(x,y): (3, 0)
(x,y): (2, 0)
(x,y): (1, 0)
(x,y): (0, 0)
(x,y): (0, 1)
(x,y): (0, 2)
Tamanhos 11
Destino Encontrado!!(x,y): (6, 2)
(x,y): (6, 3)
(x,y): (6, 4)
(x,y): (5, 4)
(x,y): (4, 4)
(x,y): (3, 4)
(x,y): (2, 4)
(x,y): (1, 4)
(x,y): (0, 4)
(x,y): (0, 3)
(x,y): (0, 2)
Tamanhos 11Destino Encontrado!!
Toda vez que ele chega no destino ele imprime essa mensagem.
Essa é a parte do código que ele para quando encontra todos os caminhos e o switch que valida conforme o critério. A outra parte do código é movimento esquerda, baixo, direita e cima.
Em 01/01/2021 às 15:52, Lucas LC disse:Em 01/01/2021 às 15:05, AdrianoSiqueira disse:Faça assim:
//Se a posição XY Inicial for igual a Final = CASO BASE if(posicaoInicial.ehigual(posicaoFinal)){ System.out.println("Destino Encontrado!!"); solucaoAtual.imprimirCaminho(); //Validar com base no critério. switch(criterio){ case 1: this.criterio1(solucaoAtual); break; case 2: this.criterio2(solucaoAtual); break; case 3: this.criterio3(solucaoAtual); break; case 4: this.criterio4(solucaoAtual); break; }
Preciso validar agora com base nos críterios colocando esse objeto solucaoAtual recebendo todos os caminhos possíveis e chamar no critério1 por exemplo, ai fica assim:public void criterio1(Solucao solucao){
if(melhor == null || solucao.tamanho() < melhor.tamanho()){
melhor = clone(solucao);
}
}
esse objeto melhor vale null no primeiro caso e depois faço uma cópia do objeto solucao para não modificar o endereço do objeto que tá lá naquele método que se movimenta. No entanto eu fiz um println e ele não faz mais comparações com o segundo caminho que é aquele que tem tamanho 11, será que eu preciso armazenar as cópias dos caminhos em um array ou faço uma outra lista para isso ?
-
Adriano boa noite!
Consegui fazer bastante coisa já e arrumei muitas coisas no código, será que você pode me ajudar com uma dica sobre cópia de objetos ?
-
1 hora atrás, AdrianoSiqueira disse:
Dê uma olhada nesse projeto, veja se ele te dá alguma inspiração.
Vou dar uma olhada sim, obrigado!
-
Adriano boa tarde!
Será que você pode me ajudar a fazer o primeiro caminho, que é o caminho com menor casas.
Deixei todos os arquivos que eu fiz em anexo.
O primeiro caminho tentei colocar um if como caso base para parar a recursão do atributo solucao, fiz um while para ele andar no labirinto, enquanto meu explorador puder ir para cima, baixo, esquerda e direita ele continua, chamo a função movimentar() para dar um passo, programei para ele ir para cima primeiro, adiciono esse movimento na lista que você me ajudou a fazer, zero as direções para ele tentar ir para cima de novo, ai nos próximos ifs fiquei meio perdido, porque preciso ter um caminho diferente para comparar ai fiz esse atributo solucao para comparar com a melhor, por isso chamei recursivamente e depois comparo o tamanho delas e retorno o caminho melhor.
21 horas atrás, Lucas LC disse:21 horas atrás, AdrianoSiqueira disse:Faça assim:
public Solucao criterio1(Posicao posicaoInicial,Posicao posicaoFinal){ if(posicaoInicial.getPosX() == posicaoFinal.getPosX() && posicaoInicial.getPosY() == posicaoFinal.getPosY()) return new Solucao(); Solucao melhor = null; while(Fim()) { movimentar(); tempoExato += calculaTempo(peso); melhor.adiciona(movimentar()); zerarDirecoes(); if(posicaoInicial.getPosX() != posicaoFinal.getPosX() && posicaoInicial.getPosY() != posicaoFinal.getPosY()) { aumentarDirecoes(); movimentar(); tempoExato1 += calculaTempo(peso); solucao.adiciona(movimentar()); solucao = criterio1(posicaoInicial,posicaoFinal); if(solucao != null && melhor == null || solucao.tamanho() < melhor.tamanho()){ melhor = solucao; }else if(melhor != null) return melhor; } } return melhor; }
Solucao.txt.txtPosicao.txt.txtMovimentoExplorador.txt.txtMain.txt.txtGame.txt.txtCriterios.txt.txt
-
2 horas atrás, AdrianoSiqueira disse:
Funciona, mas é desnecessário.
Entendi, obrigado!!
-
45 minutos atrás, AdrianoSiqueira disse:
Faça assim:
int getTamanho(){ return filaCoordenadas.size(); }
Isso vai retornar a quantidade de itens na lista, que por sua vez é a quantidade de passos.
Ata, pensei em inicializar uma variável com 0 e meu for percorre a lista, cada vez que ela achar um objeto ela incrementa e retorna o tamanho.
-
15 horas atrás, AdrianoSiqueira disse:
A classe Posicao ficou legal, mas a classe solução está errada.
Perceba que no método adiciona você está criando um ArrayList, isso significa que você vai criar uma lista nova toda vez que tentar adicionar uma posição e essa lista vai se perder, pois não está fazendo nada com ela. Crie o ArrayList fora do método, como se fosse um atributo dessa classe.
Outra coisa, você está recebendo o objeto Posicao via parâmetro, então não deveria instanciar um novo objeto, pois vai perder a informação que você recebeu.
Entendi, obrigado mesmo pela ajuda.
ficou assim então:
20 horas atrás, Lucas LC disse:import java.util.ArrayList;
import java.util.Collections ;
import java.util.PriorityQueue ;
public class Solucao{
ArrayList<Posicao> filaCoordenadas = new ArrayList<Posicao>();
public void adiciona(Posicao p){
filaCoordenadas.add(p);
}
public int tamanho(){
int tamanho = 0;
for(Posicao p : filaCoordenadas){
tamanho++;
}
return tamanho;
}
15 horas atrás, AdrianoSiqueira disse:Deveria ser algo assim:
// ... public class Solucao { private ArrayList<Posicao> list = new ArrayList<>(); public void adicionar(Posicao p) { list.add(p); } // ...
Assim eu consigo fazer o histórico das coordenadas que chegou até o final do caminho certo ?
Ai eu só comparo o tamanho dessas listas para ver qual é a menor ou maior.
-
Boa tarde amigo.
Eu fiz a classe solução igual a sua ideia, queria saber se tá certo.
A classe Posição é instanciada no método main colocando a posição inicial e final. O getPosX() e getPosY() marca a posição atual do explorador.
CLASSE SOLUÇÃO PARA REGISTRAR O HISTÓRICO DE COORDENADAS.
21 horas atrás, AdrianoSiqueira disse:import java.util.ArrayList; import java.util.Collections ; import java.util.PriorityQueue ; public class Solucao{ public void adiciona(Posicao p){ //Crio uma fila de coordenadas. ArrayList<Posicao> filaCoordenadas = new ArrayList<Posicao>(); p = new Coordenada(getPosX(), getPosY()); filaCoordenadas.add(p); } public int tamanho(){ int tamanho = 0; for(Posicao p : filaCoordenadas){ tamanho++; } return tamanho; } }
CLASSE POSIÇÃO.
21 horas atrás, AdrianoSiqueira disse:public class Posicao{ //Chamando de xy. private int posX; private int posY; //Iniciar a posição. public Posicao(int PosX, int PosY) { this.posX = PosX; this.posY = PosY; } public int getPosX(){ return this.posX; } public void setPosX(int posX){ this.posX = posX; } public int getPosY(){ return this.posY; } public void setPosY(int posY){ this.posY = posY; } public void imprimePosicoes(){ System.out.println("X: " + this.getPosX() + "\t Y: " + this.getPosY()); } }
-
Olá bom dia!
Gostaria de uma ajuda.
Estou fazendo um labirinto em java, a ideia principal é que um explorador está nesse labirinto e ele pode se movimentar em 4 direções(cima,baixo,direita e esquerda), até chegar no seu destino.
Preciso implementar 4 caminhos para o meu labirinto, segue abaixo:
1. Caminho mais curto. Isto é, que passe pelo menor número possível de casas.
2. Caminho mais longo. Isto é, que passe pelo maior número possível de casas (ok, este é um
critério estranho, mas pense que o explorador possui motivos para visitar o maior número de casas
possível sem passar mais de uma vez por uma mesma casa).3. Caminho mais valioso. Isto é, que maximiza o valor dos itens coletados.
4. Caminho mais rápido. Ou seja, aquele minimiza o tempo que se leva para chegar no
destino (note que não necessariamente equivale ao mais curto, pois depende dos itens que são coletados
no caminho, o que por sua vez afeta o tempo necessário para percorrê-lo).Para fazer esses caminhos eu fiz um método movimentar, retornarMovimento (caso não dê as 4 direções ele retorna uma casa).
private void aumentarDirecoes() { this.direcoes += 1; } public void movimentar() { //Parar caso não de as 4 direções. if(this.direcoes >= 4) return; Posicao retornarMovimento = retornarMovimento(); //saber o local que ele está. String valor = this.game.retornarValorPosicaoLabirinto(retornarMovimento); //Caso o valor retornado seja o do próprio explorador ou a passagem esteja bloqueada não faça nada ou entrou um item. if(valor.equals("X")) { proximoMovimento(); aumentarDirecoes(); //Se não de certo tente novamente. movimentar(); } else { this.posInicial = retornarMovimento; } } private void proximoMovimento() { switch(this.movimento) { case CIMA: this.movimento = MovimentoExplorador.BAIXO; break; case BAIXO: this.movimento = MovimentoExplorador.ESQUERDA; break; case ESQUERDA: this.movimento = MovimentoExplorador.DIREITA; break; case DIREITA: this.movimento = MovimentoExplorador.CIMA; break; } } //Em um algoritmo de tentativa e erro, sempre tem a possibilidade de retornar o movimento que não dá certo. public Posicao retornarMovimento() { int retornoPosX = this.posInicial.getPosX(); int retornoPosY = this.posInicial.getPosY(); //Caso o explorador for para cima, para retornar uma posição ele precisa ser maior que 0. switch(movimento) { case CIMA: if(retornoPosX > 0) { retornoPosX -= 1; } break; case BAIXO: if(retornoPosX < this.game.getLines() -1){ retornoPosX +=1; } break; case ESQUERDA: if(retornoPosY > 0) { retornoPosY -= 1; } break; case DIREITA: if(retornoPosY < this.game.getColumn() -1){ retornoPosY += 1; } break; } return new Posicao(retornoPosX, retornoPosY); }
Esse método movimento ele faz apenas 1 movimento, logo na implementação do primeiro caminho para encontrar o menor número de casas eu pensei em criar uma classe que adicione as coordenadas desse movimento, mas é claro vou precisar mudar esse método movimentar para retornar as coordenadas que ele foi, então toda vez que ele fizer um movimento ele adiciona as coordenadas na outra classe e depois eu só comparo os tamanhos das listas para encontrar a menor, porém para fazer isso pensei em usar um arraylist, mas não sei como utilizar perfeitamente, alguém poderia ajudar ?
-
Bom dia pessoal!
Tenho que implementar um labirinto com 4 caminhos possíveis, sendo eles:
1. Caminho mais curto. Isto é, que passe pelo menor número possível de casas.
2. Caminho mais longo. Isto é, que passe pelo maior número possível de casas (ok, este é um critério estranho, mas pense que o explorador possui motivos para visitar o maior número de casas possível sem passar mais de uma vez por uma mesma casa).
3. Caminho mais valioso. Isto é, que maximiza o valor dos itens coletados.
4. Caminho mais rápido. Ou seja, aquele minimiza o tempo que se leva para chegar no destino (note que não necessariamente equivale ao mais curto, pois depende dos itens que são coletados no caminho, o que por sua vez afeta o tempo necessário para percorrê-lo).
O labirinto é representado por uma matriz e a movimentação pelo labirinto pode se dar em 4 direções: para cima, para baixo, para a esquerda e para a direita. Um caminho que leva o explorador da origem ao destino só pode passar por cada posição uma única vez.
Esses 4 caminhos preciso fazer usando a definição de um algorítmo de tentativa e erro.
Gostaria de saber se alguem tem alguma ideia de como fazer os caminhos ou se tem alguma página na net que conheça sobre o assunto.
-
Em 19/12/2020 às 13:29, arfneto disse:
Até mostrei uma implementação:
int hp_heapsort(int heap[], int tamanho) { while (tamanho > 1) heap[tamanho--] = extract_max(heap, tamanho); return 0; }; // heapsort()
Mas é para ilustrar o que significa você implementar algo a partir de um Max/MinHeap, no sentido de que estou dizendo que formalmente você iria implementar a fila de prioridade usando um Heap. Usando somente as funções de Heap, sem misturar as coisas, como seria o caso se o Heap fosse fornecido pela linguagem. Separado. Espero que agora dê para entender melhor. Não sou seu orientador, no entanto
e se fosse você não usaria
Em 16/12/2020 às 14:52, Lucas LC disse:uma forma de implementar os dois ao mesmo tempo esse trabalho
porque isso iria contra todo o princípio de objetos, encapsulamento e o princípio de não reinventar coisas.
O arranjo correspondente ao heap não fica ordenado, por isso não precisamos do método heapSort em si: o arranjo corresponderá ao heap máximo: cada elemento terá prioridade maior ou igual à prioridade de seus filhos, mas não necessariamente será um arranjo ordenado.
-
Em 23/11/2020 às 17:38, arfneto disse:
Sua estrutura estará organizada como Max_Heap num dado momento?
Desculpa por sumir, estava com alguns problemas.
Então fiz sim maxHeap que chama uma função MaxHeapfy que faz essa manutenção, por exemplo: caso o elemento incluído no última posição ele é inserido e colocado na posição correta no heap usando a prioridade dele, a fila de prioridade fina no arranjo de ponteiros que guarda o endereço de todos os elementos inseridos, o heap seria uma forma de implementar os dois ao mesmo tempo esse trabalho.
Consegui fazer já e está funcionando corretamente, colocarei no GitHub e mostrarei para você depois.
Em 25/11/2020 às 00:10, arfneto disse:E o heapsort()?
De acordo com o meu orientador não precisa de heapsort.
Em 25/11/2020 às 00:10, arfneto disse:Essa estrutura
typedef struct st_ex { int id; int posicao; float prioridade; } ELEMENTO, * PONT; typedef float Key; typedef ELEMENTO Dado; typedef struct { Dado* x; Key k; // prioridade } Elemento; typedef struct { unsigned incremento; unsigned limite; unsigned tamanho; Elemento** E; // max_heap } P Q, S;
Provavelemente serviria para envolver seus dados e resolver seu programa de um modo bem simples, com funções de poucas linhas e fáceis de ler e alterar. E ficaria com as funções
tanto de heap quanto de p q para o futuro.
É preciso escrever P e Q separados porque o software b0b1nh0 desse forum troca p q por "porque" mesmo que sejam variáveis dentro de um programa. Genial!!!
Entendi arfneto, obrigado pelas dicas.
-
19 horas atrás, arfneto disse:
Se não disser onde e o que mudou não vou saber como arrumar seu programa em relação a id...
Na verdade eu simplesmente tirei aquela parte e deixei a variável posição em 0, fiz a verificação da fila, se ela está vazia sim ou não, coloquei o endereço da primeira posição no ponteiro atual, decrementei o f->elementosNoHeap, coloquei o último elemento na primeira posição e chamei a reduzirPrioridadeAux, organizando meu heap.
PONT removerElemento(PFILA f){ PONT res = NULL; int id; PONT atual; int posicao = 0; //Verificar se a fila não está vazia. if(f == NULL) return res; if(f->elementosNoHeap == 0) return res; //A primeira posição precisa ser excluida. atual = f->heap[0]; f->elementosNoHeap--; f->heap[0] = f->heap[f->elementosNoHeap]; reduzirPrioridadeAux(f,0); //Colocar NULL na posição do arranjo. int excluir = atual->id; f->arranjo[excluir] = NULL; res = atual; return res; }
19 horas atrás, arfneto disse:Li rapidamente seu programa a tarde. O que ainda não entendi: em geral Heap não usa ponteiros. Essa é afinal a grande vantagem dessa estrutura, que é muito muito rápida e baseada justamente em índices. Claro que os índices podem ser ponteiros, mas não entendo porque se faria isso. O que são os dois ponteiros que usa? heap e arranjo? Heap é ajustado sempre in-place...
Essencialmente um Max Heap --- ou um Min Heap --- se cuida sozinho. A cada mudança você chama max_heapify(). Só isso.
Nesse programa o heap corresponde a um ponteiro para um arranjo de ponteiros para elementos do tipo ELEMENTO, este arranjo representará o heap máximo, seu tamanho será igual a maxElementos e o campo elementosNoHeap determinará quantos elementos válidos estão no heap em um dado momento e o arranjo corresponde a um ponteiro para um arranjo de ponteiros para elementos do tipo ELEMENTO, que irá guardar todos os elementos inseridos, a estrutura heap vai ter alguns métodos para fazer a manutenção dessa estrutura como esses dois que eu fiz :
Esse aumentarPrioridadeAux2 será usando quando eu inserir um elemento na última posição ou aumentar a prioridade de algum elemento no arranjo e heap e preciso colocar ele no lugar certo do heap máximo, caso sua prioridade seja maior e o reduzirPrioridadeAux uso ele em reduzir prioridade para descer o elemento que tiver prioridade menor que seus filhos e caso o 1 elemento do heap seja excluido, ai eu excluo do heap e arranjo.
exemplo:
//Função para trocar a posição dos elementos no heap. void troca(PONT* a, PONT* b){ PONT t = *a; *a = *b; *b = t; } //Se o atual tiver prioridade maior do que a de seu pai, os dois devem trocar de lugar). void aumentarPrioridadeAux2(PFILA f, PONT atual){ int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; if(atual->prioridade > f->heap[(i-1)/2]->prioridade){ troca(&(atual), &(f->heap[(i-1)/2])); } } } //Descer elemento no Heap void reduzirPrioridadeAux(PFILA f, int posicao){ int maiorFilho = -1; for (posicao=0;posicao<f->elementosNoHeap;posicao++){ if(2*posicao+1 < f->elementosNoHeap){ maiorFilho = 2*posicao+1; if(2*posicao+2 < f->elementosNoHeap && (f->heap[2*posicao+1]->prioridade) < (f->heap[2*posicao+2]->prioridade)) maiorFilho = 2*posicao+2; if(maiorFilho>-1 && f->heap[posicao]->prioridade < f->heap[maiorFilho]->prioridade) { troca(&(f->heap[posicao]), &(f->heap[maiorFilho])); } } } }
Não sei se deu para entender agora, o que estou com problemas é nessa função de troca, ele pode até trocar elementos de lugar, mas eles não trocam de posição.
-
2 horas atrás, arfneto disse:
removerElemento() começa com
PONT atual = f->arranjo[id];
mas de onde vem id?
Não foi inicializado no método nessa parte eu já mudei, me equivoquei.
2 horas atrás, arfneto disse:Um heap não é uma pilha. E pode ser visto como uma árvore binária balanceada, exceto talvez por um nó.
Exatamente, ele não entra na definição de pilha e sim de uma árvore quase completa.
2 horas atrás, arfneto disse:Não há razão para sequer pensar nisso. É a linguagem. E aí você define um tipo PFILA. Será um ponteiro? Não soma nada. E se todo ponteiro começa por P sempre tem outra ambiguidade: Um ponteiro para um ponteiro começaria por PP? Para que? PONT é um ponteiro para ONT? Acho que deu para entender. Se tem um tipo FILA então para que precisa de PFILA? Ah, PFILA é um ponteiro para FILADEPRIORIDADE. Sério?
Sim, PFILA é um ponteiro da fila de prioridade. E também a estrutura não pode ser mudada.
2 horas atrás, arfneto disse:Em relação ao programa, vou repetir o que sempre escrevo: Nunca use typedefs para ponteiros. Só dá confusão. Essas linguagens tem o asterisco precisamente para isso:
Exemplo
Se argv é char** então- *argv é char*
- **argv é char
Sim entendi, na verdade eu até me acostumei de usar typedefs como ponteiros.
-
Ok, vou colocar as informações que estou usando para executar.
filaDePrioridade.txt usaFilaDePrioridade.txt
Coloquei as referências usadas e o arquivo de teste.
A inserção está correta.
Quando uso a função void aumentarPrioridadeAux2(PFILA f, PONT atual), ela aumenta a prioridade, mas não corretamente, tentei fazer isso usando o PONT atual, o int posicao e até uma função recursiva, fazendo o mesmo trabalho.
A mesma coisa acontece em diminuir prioridade.
-
1
-
-
Boa noite!
Estou fazendo uma fila de prioridade heap, são dois vetores de ponteiros que guardam os elementos inseridos, o método de inserir consegui fazer, mas as outras não consegui muito bem, gostaria de algumas dicas, criei alguns métodos auxiliares para fazer a manutenção da estrutura heap que são: refazHeapMaximo, maxHeapify, aumentarPrioridadeAux, reduzirPrioridadeAux.
As duas últimas são subir heap, quando a prioridade de um elemento é modificada ele precisa subir na árvore e o descer é quando sua prioridade diminui. A estrutura heap é uma árvore que tem 2 filhos e 1 pai, os dois filhos precisam ser menores que seu pai, por isso essas funções auxiliares.
No método aumentar prioridade, reduzir prioridade e remover, está em um loop infinito .
Se alguém puder ajudar agradeço.
PFILA criarFila(int max){ PFILA res = (PFILA) malloc(sizeof(FILADEPRIORIDADE)); res->maxElementos = max; res->arranjo = (PONT*) malloc(sizeof(PONT)*max); res->heap = (PONT*) malloc(sizeof(PONT)*max); int i; for (i=0;i<max;i++) { res->arranjo[i] = NULL; res->heap[i] = NULL; } res->elementosNoHeap = 0; return res; } void exibirLog(PFILA f){ printf("Log [elementos: %i]\n", f->elementosNoHeap); PONT atual; int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; printf("[%i;%f;%i] ", atual->id, atual->prioridade, atual->posicao); } printf("\n\n"); } //Função para trocar a posição dos elementos no heap. void troca(PONT* a, PONT* b){ PONT t = *a; *a = *b; *b = t; } //Posição do filho a esquerda é 2i+1, direita 2i+2, (i-1)/2 é o pai e o 0 é a raiz. void maxHeapify(PFILA f, PONT atual, int posicao){ int esquerda = 2*posicao+1; int direita = 2*posicao+2; int max; //Propriedade para fazer a manutenção da árvore. if(esquerda <= f->maxElementos && f->heap[esquerda]->prioridade > f->heap[posicao]->prioridade ){ max = esquerda; } else { max = posicao; } if(direita <= f->maxElementos && f->heap[direita]->prioridade > f->heap[max]->prioridade){ max = direita; } //Fazer a troca do elemento na posição maior. if(max != posicao){ atual = f->heap[posicao]; f->heap[posicao] = f->heap[max]; f->heap[max] = atual; maxHeapify(f,atual,max); } return; } //Será usado quando removemos um elementos ou reduzimos sua prioridade. //Árvore binária quase completa em que cada pai é maior ou igual que qualquer de seus filhos. void refazHeapMaximo(PFILA f, PONT atual){ //Decrescendo para encontrar o maior valor para a manutenção da árvore. for(int posicao=f->maxElementos/2;posicao>=0;posicao--){ atual = f->heap[posicao]; if(atual->prioridade > f->heap[(posicao-1)/2]->prioridade){ maxHeapify(f,atual,posicao); } } } //Sobe no Heap, função interativa void aumentarPrioridadeAux(PFILA f, int posicao){ int i = posicao; //Caso o pai seja menor que seus filhos. while(i > 0 && f->heap[(i-1)/2]->prioridade < f->heap[i]->prioridade) { troca(&(f->heap[i]), &(f->heap[(i-1)/2])); i = (i-1)/2; } } //Se o atual tiver prioridade maior do que a de seu pai, os dois devem trocar de lugar). void aumentarPrioridadeAux2(PFILA f, PONT atual){ int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; if(atual->prioridade > f->heap[(i-1)/2]->prioridade){ troca(&(atual), &(f->heap[(i-1)/2])); } } } //Descer elemento no Heap void reduzirPrioridadeAux(PFILA f, int posicao){ int maiorFilho; for (posicao=0;posicao<f->elementosNoHeap;posicao++){ if(2*posicao+1 < f->maxElementos){ maiorFilho = 2*posicao+1; if(2*posicao+2 < f->maxElementos && (f->heap[2*posicao+1]->prioridade) < (f->heap[2*posicao+2]->prioridade)) maiorFilho = 2*posicao+2; if(f->heap[posicao]->prioridade < f->heap[maiorFilho]->prioridade) { troca(&(f->heap[posicao]), &(f->heap[maiorFilho])); } } } } void reduzirPrioridadeAux2(PFILA f, PONT atual){ int maiorFilho; int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; if(2*i+1 < f->maxElementos){ maiorFilho = 2*i+1; atual = f->heap[maiorFilho]; if(2*i+2 < f->maxElementos && (f->heap[2*i+1]->prioridade) < (f->heap[2*i+2]->prioridade)) maiorFilho = 2*i+2; atual = f->heap[maiorFilho]; if(f->heap[i]->prioridade < atual->prioridade) { troca(&(f->heap[i]), &(atual)); } } } } //Quantidade de elementos no heap. int tamanho(PFILA f){ int tam = 0; for(int i=0; i<f->elementosNoHeap;i++){ tam++; } return tam; } bool inserirElemento(PFILA f, int id, float prioridade){ bool res = false; ELEMENTO* novoElemento; PONT atual; int posicao = f->elementosNoHeap; // posição inicial do novo elemento no arranjo chamado heap //id precisa ser válido e menor que maxElementos na estrutura. if(id < 0 || id >= f->maxElementos) return res; //Não incluir elementos repetidos. if(f->arranjo[id] != NULL) return res; atual = f->arranjo[id]; //Alocar memória para esse elemento. novoElemento = (PONT) malloc(sizeof(ELEMENTO)); //Guarde ele no arranjo de endereços. f->arranjo[id] = novoElemento; f->heap[f->elementosNoHeap] = novoElemento; // o novo elemento deve ser inserido na primeira posição livre do arranjo heap novoElemento->prioridade = prioridade; novoElemento->id = id; novoElemento->posicao = f->elementosNoHeap; f->elementosNoHeap++; aumentarPrioridadeAux(f,posicao); res = true; return res; } bool aumentarPrioridade(PFILA f, int id, float novaPrioridade){ bool res = false; PONT atual = f->arranjo[id]; if(f == NULL) return res; if (id < 0) return false; // id negativo if (id >= (f->maxElementos)) return res; //Verificar se os elementos do arranjo são válidos ou se tem alguém ou não. if (f->arranjo[id] == NULL) return res; // Caso a prioridade de um determinado elemento for maior que a variável passado como parâmetro retorne false. if (f->arranjo[id]->prioridade >= novaPrioridade) return res; atual->prioridade = novaPrioridade; aumentarPrioridadeAux2(f,atual); res = true; return res; } bool reduzirPrioridade(PFILA f, int id, float novaPrioridade){ bool res = false; PONT atual = f->arranjo[id]; if(f == NULL) return res; if (id < 0) return false; // id negativo if (id >= (f->maxElementos)) return res; // id > maximo // Se não tem na fila retorne false. if (f->arranjo[id] == NULL) return res; // Caso a prioridade de um determinado elemento for menor que a variável passado como parâmetro retorne false. if (f->arranjo[id]->prioridade <= novaPrioridade) return res; atual->prioridade = novaPrioridade; reduzirPrioridadeAux2(f,atual); refazHeapMaximo(f,atual); res = true; return res; } PONT removerElemento(PFILA f){ PONT res = NULL; int id; PONT atual = f->arranjo[id]; int posicao; //Verificar se a fila não está vazia. if(f == NULL) return res; if(f->maxElementos == 0) return res; for(posicao = f->elementosNoHeap;posicao >= 0; posicao--) //A primeira posição precisa ser excluida. if(posicao == 0) atual = f->heap[posicao]; f->elementosNoHeap--; f->heap[posicao] = f->heap[f->elementosNoHeap]; reduzirPrioridadeAux(f,0); //Colocar NULL na posição do arranjo. int excluir = atual->id; f->arranjo[excluir] = NULL; refazHeapMaximo(f,atual); res = atual; return res; } bool consultarPrioridade(PFILA f, int id, float* resposta){ bool res = false; if(f == NULL) return res; if (id < 0) return res; // id negativo if (id >= (f->maxElementos)) return res; if (f->arranjo[id] == NULL) return res;//Se os elementos da fila for válido. *resposta = f->arranjo[id]->prioridade;//Colocar na memória o valor da prioridade. res = true; return res; }
-
import java.awt.*; import java.awt.image.*; import javax.imageio.*; import java.io.*; public class Koch extends Image { //declaracoes de tipo int largura, altura; double PA,AB,BC,CQ; double cos60,sen60; public void inicio() { //Coordenadas iniciais PA = 40; AB = largura - 40; BC = altura - 80; CQ = BC; cos60 = Math.cos(3.1415927/3.); sen60 = Math.sin(3.1415927/3.); } public void Koch(Graphics imagem,int l,double Px,double Py,double Qx,double Qy){ int c; //Caso o limite seja menor que o comprimento. if ( l < c ) imagem.drawLine( (int)Px, (int)Py, (int)Qx, (int)Qy ); else{ l = l - 1; double Ax = Px + (Qx-Px)/3.;//Ponto A, sendo 1/3. double Ay = Py + (Qy-Py)/3.; double Cx = Qx - (Qx-Px)/3.;//Ponto C, sendo 2/3. double Cy = Qy - (Qy-Py)/3.; double Bx = Ax + cos60*(Cx-Ax) + sen60*(Cy-Ay);// +: vira o desenho 60 graus no sentido horário. double By = Ay - sen60*(Cx-Ax) + cos60*(Cy-Ay); //-: vira o desenho 60 graus no sentido anti-horário. Koch(imagem, l, Px, Py, Ax, Ay ); Koch(imagem, l, Ax, Ay, Bx, By ); Koch(imagem, l, Bx, By, Cx, Cy ); Koch(imagem, l, Cx, Cy, Qx, Qy ); } } }
-
Alguém poderia dar uma ajuda ou algumas dicas.
Preciso implementar um código que imprima uma curva de koch, como essa:
Fiz uma classe mãe que se chama Image, segue o código:
import java.awt.*; import java.awt.image.*; import javax.imageio.*; import java.io.*; public class Image { private int width, height; private BufferedImage image; private Graphics graphics; private Color color; private Color bgColor; public Image(int w, int h, int r, int g, int b){ setup(w, h, r, g, b); } public Image(int w, int h){ setup(w, h, 0, 0, 0); } private void setup(int w, int h, int r, int g, int b){ image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); width = image.getWidth(); height = image.getHeight(); graphics = image.createGraphics(); setBgColor(new Color(limit(r), limit(g), limit(b))); setColor(Color.WHITE); clear(); } private int limit(int value){ return value < 0 ? 0 : (value > 255 ? 255 : value); } public void setBgColor(Color c){ bgColor = c; } public void setBgColor(int r, int g, int b){ setBgColor(new Color(limit(r), limit(g), limit(b))); } public void setColor(Color c){ color = c; } public void setColor(int r, int g, int b){ setColor(new Color(limit(r), limit(g), limit(b))); } public void clear(){ graphics.setColor(bgColor); graphics.fillRect(0, 0, width, height); } public void setPixel(int x, int y){ if(x >= 0 && y >= 0 && x < width && y < height){ image.setRGB(x, y, color.getRGB()); } } public int getPixel(int x, int y){ return image.getRGB(x, y); } public void drawLine(int x1, int y1, int x2, int y2){ graphics.setColor(color); graphics.drawLine(x1, y1, x2, y2); } public void save(String fileName){ try{ ImageIO.write(image, "png", new File(fileName)); } catch(IOException e){ System.out.println("Unable to save image..."); e.printStackTrace(); } } }
Tenho outra classe que converte o arquivo txt em imagem e ela imprime uma paisagem sem nada, da uma olhada:
Agora preciso implementar uma classe filha da curva de koch, porém não sei bem como fazer isso. Sendo que a implementação tem que receber como parâmetros as coordenadas x e y dos pontos P e Q e o valor l do limiar.
Sobre o Clube do Hardware
No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais
Direitos autorais
Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais
RJava e RCaller Diferença
em Java/Android SDK
Postado
Boa noite pessoal!
Gostaria de saber a diferença entre o Rjava e o Rcaller, pelo que eu entendi, ambos fornece funções do R para ser executado no Java, já que possui uma interface de alto nível.