Jump to content
Comet

Subsequências ordenadas de forma decrescente

Recommended Posts

Comet

Boas precisava de uma ajuda num trabalho e não estou a conseguir perceber muito bem como fazer. Podiam dar uma ajudinha????

1. Defina o método estático:

List<List<Integer>> getSubSequences( Iterator<Integer> it, Comparator<Integer> cmp )

que produza uma lista das subsequências ordenadas, de forma crescente segundo o comparador cmp, existentes na

sequência, iterada por it.

Exemplo para um comparador que compara pela ordem natural:

Sequência iterada por it -> [10, 20, 30, 12, 13, 8, 1, 2, 3]

Lista produzida -> [[10, 20, 30], [12, 13], [8], [1, 2, 3]]

Share this post


Link to post
Share on other sites
HappyHippyHippo

diz-me tu : o que faz com que separes uma sub lista da outra ?

(eu sei a resposta, estou a ver ser consegues chegar tu à solução)


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
Comet

será criar uma sublista sempre que necessário?

Para depois na lista principal inserir as sublistas

Share this post


Link to post
Share on other sites
HappyHippyHippo

xiii ... estás a milhas da solução

1º -

o resultado é uma nova lista, não tem nada haver com a lista principal

2º -

uma resposta do género sempre que necessário é como no código da estrada

"a velocidade limite de marcha é aquela que permite executar uma travagem que evitando qualquer tipo de acidente, desde que não ultrapasse os limites impostos pelos tipos de vias ou sinalização auxiliar"

agora responde a esta esta questão : "qual é o limite de velocidade ?"


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
Rui Carlos

xiii ... estás a milhas da solução

Quando li a resposta, não me pareceu que estivesse assim tão longe :D

Realmente o "sempre que necessário" não diz muito (mas assumi que soubesse do que se tratava).

Também assumi que por "lista principal" ele quisesse dizer "lista que será devolvida", e não necessariamente "lista original".

Mas dependendo do que ele estava efectivamente a pensar, poderá estar mais longe ou mais perto...

Comet, tenta colocar a tua ideia num algoritmo (em pseudo-código, ou mesmo em código Java).

Share this post


Link to post
Share on other sites
Comet

Obrigado mas já consegui resolver o problema

public static class comparatorInt implements Comparator<Integer>{

@Override
 public int compare(Integer o1, Integer o2) {
if (o2>o1)return -1;
if (o2==o1)return 0;
return 1;
 }
}

public static List<List<Integer>> getSubSequences( Iterator<Integer> it, Comparator<Integer> cmp ) throws OperationNotSupportedException {
 List<List<Integer>> asd = new LinkedList<>();
 ArrayList<Integer> aux = new ArrayList<>();
 Integer auxint0=null;
 Integer auxint1=null;
 if(it.hasNext()){
auxint1=it.next();
aux.add(auxint1);
auxint0=auxint1;
 }

 while (it.hasNext()) {
auxint1=it.next();
if (cmp.compare(auxint0,auxint1)==-1){
  aux.add(auxint1);
  auxint0=auxint1;
}
else if (cmp.compare(auxint0, auxint1)==0) throw new OperationNotSupportedException();
else if (cmp.compare(auxint0, auxint1)==1){
  asd.add(aux);
  aux=new ArrayList<>();
  aux.add(auxint1);
  auxint0=auxint1;
}
 }
 asd.add(aux);
 return asd;
}

Edited by Rui Carlos
Formatação do código.
  • Vote 1

Share this post


Link to post
Share on other sites
HappyHippyHippo

exemplo completo com um código um pouco mais OOP:

import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.LinkedList;

public class Seq {

 public static List<List<Integer>> getSubSequences( Iterator<Integer> it, Comparator<Integer> cmp ) {
   List<List<Integer>> result = new LinkedList<List<Integer>>();
   List<Integer> list = null;

   while (it.hasNext()) {
     Integer i = it.next();

     if (list == null || cmp.compare(list.get(list.size() - 1), i) < 0) {
       list = new LinkedList<Integer>();
       result.add(list);
     }

     list.add(i);
   }

   return result;
 }

 public static void main(String[] args) {
   List<Integer> list = new LinkedList<Integer>();
   list.add(10).add(20).add(30).add(12).add(13).add(8).add(1).add(2).add(3);

   // chamada da função getSubSequences com um comparados anónimo
   List<List<Integer>> subseq = getSubSequences(list.iterator(), new Comparator<Integer>() {
     public int compare(Integer o1, Integer o2) { return o2 - o1; }
   });

   // apresentação das sublistas
   int i = -1;
   Iterator<List<Integer>> it = subseq.iterator();
   while (it.hasNext()) {
     i++;
     Iterator<Integer> sit = it.next().iterator();
     while (sit.hasNext()) {
       System.out.print(i + " >> ");
       System.out.println(sit.next());
     }
   }
 }
}

Edited by HappyHippyHippo

IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.