✔ tails() implementieren.... aber wie

[psychoDe]

guude leute,

ich sitz hier grad an einer Java aufgabe bei der wir mit listen arbeiten sollen.
ein paar implementierungen hab ich jetzt schon hinter mir, jedoch hänge ich an der "tails()". ich muss sagen das listen nicht gerade meine stärken sind und ich wirklich sehr viele mühe bei der aufgaben habe. ich möchte jetzt nicht direkt ne lösung haben aber ein paar tipps wie ich bei der implementierung vorran gehen muss wären wirklich super

das soll sie machen:
----------------------
tails

public Li<Li<A>> tails()

Description copied from interface: Li
Makes a list of lists of all taillists. example: for the list ("this","is","a","test")
this produces: (("this","is","a","test"),("is","a","test"),("a","test"),("test"))

Specified by:
tails in interface Li<A>

Returns:
a list of lists, which contains all list obtained from this list through several calls of tail().
------------------------

hier soll das ganze rein.. etwas weiter unten

package name.panitz.eliza;

import java.util.Collections;
import java.util.List;

/**
   A concrete implementation of abstract class Li.
 **/
public class LiImpl<A> implements Li<A>
{
  boolean empty = true;
  private A hd = null;
  public Li<A> tl = null;
 
  public LiImpl(){}
  public LiImpl (A x,Li<A> xs)
  {
	  hd = x;
	  tl = xs;
	  empty = false;
  }
  Data d ;
  public static <B> Li<B>empty()
  {
	  return new LiImpl<B>();
  }
  
  public static <B> Li<B>   cons(B x,Li<B> xs)
  {
	  return new LiImpl<B>(x,xs);
  }
  
  public boolean isEmpty() 
  {
	  return empty;
  }  
  
  public A head()
  {
	  return hd;
  }
  
  public Li<A> tail()
  {
	  return tl;
  }

  public void rotate()
  {
    LiImpl<A> lastCons = this;
    while (!lastCons.tail().isEmpty())
    {
      lastCons =  (LiImpl<A>)lastCons.tail();
    }
    lastCons.tl = cons(head(),new LiImpl<A>());

    hd = tl.head();
    tl = tl.tail();
  }  


  public Li<A> filter(FilterCondition<A> cond){
    Li<A> result = empty();

    //test all elements of this list
    for (Li<A> xs=this;!xs.isEmpty();xs=xs.tail()){

      //in case that the condition is true for the element
      if (cond.condition(xs.head())) {
        //then add it to the result
        result = cons(xs.head(),result);
      }
    }
    return result;
  }

  /**
     @return the number of elements in this list.
  **/
  public int length()
  {
    if (isEmpty())
    	return 0;
    
    return 1+tail().length();
  }

  public String toString()
  {
    return "("+toStringAux()+")";
  }

  private String toStringAux()
  {
    if (isEmpty()) 
    	return "";
    else if (tail().isEmpty())
    	return head().toString();
    
    else
    	return head().toString()+","+((LiImpl<A>)tail()).toStringAux();
  }

  public Li<A> append(Li<A> that)
  {
    if (isEmpty())
    	return that;
    
    return cons(head(),tail().append(that));
  }

  public Li<A> concat(Li<A> that)
  {
	  return append(that);
  }

  //////////////////////////////////  todo: implement these methods///

  public Li<A> drop(int i)
  {
	if(i > 0 && !isEmpty())
		return tail().drop(i-1);
	else
		return this;
  }
  
  public Li<A> reverse()
  {
	     Li<A> temp = new LiImpl<A>(); 

	     for(Li<A> tmp = this; !tmp.isEmpty(); tmp = tmp.tail())
	     {
	               temp = cons(tmp.head(),temp);
	     }
	     return temp;  
  }
  
  
  public Li<Li<A>> tails()
  {
	  return null;
  }

  public String unwords()
  {
    return null;
  }

  public java.util.Iterator<A> iterator(){
    return null;
  }

  
}

vielen dank schonmal für eure hilfe....

 

[zeja]

Überleg dir mal wie du es von Hand machen würdest wenn deine Liste aus Papierschnipseln oder sowas bestehen würde.

Genauso musst du es eigentlich auch nur Programmieren

 

[psychoDe]

liste einfügen, 1. inhalt löschen, liste einfügen, 1. inhalt löschen, liste einfügen, usw...
bin grad am überlegen ob ich mit der "drop()" arbeiten sollte, welche mir ja die ersten i elemente entfernt.
------------------------------------------------------------------

so ich hab jetzt mal was... aber es will immernoch nicht so richtig:

public Li<Li<A>> tails()
  {
	  Li<A> temp = new LiImpl<A>();
	  
          //die komplette liste in temp einfügen
	  temp = concat(this);
	  
          
	  for(Li<A> tmp = this; !tmp.isEmpty(); tmp = tmp.tail())
	  {
                  // lösche 1. element
		  this.drop(1);		  
                  // füge restliche liste in temp ein
		  temp.append(this);
	  }
	  
          // was muss / sollte ich hier returnen
	  return temp;
  }

 

[zeja]

Du benötigst zwei verschiedene Listen:
Eine Ergebnisliste result, die du am Ende zurückgibst, und eine Liste temp auf der du immer ein Element wegschmeissen kannst und das Ergebnis dann der Ergebnisliste hinzufügst.

 

[psychoDe]

ich bekomm es einfach nicht gebacken...
wie kann ich denn eine Liste Li<Li<A>> erstellen und dann wieder ausgeben?
nicht mit casten oder
stimmt denn der rest soweit?

  public Li<Li<A>> tails()
  {
	  Li<A> temp = new LiImpl<A>();
	  Li<A> result = new LiImpl<A>();
	  
	  result = concat(this);
	  
	  for(temp = this; !temp.isEmpty(); temp = temp.tail())
	  {
		  temp.drop(1);		  
		  result.concat(this);
	  }
	  
	  return (Li<Li<A>>) result;
  }

 

[zeja]

Lass dir doch mal mittels System.out.println und deiner toString Methode ausgeben was jeweils in den einzelnen Schritten in deinen Listen enthalten ist. So ist es jedenfalls noch nicht richtig.

 

[psychoDe]

hab die lösung zwar schon ne weile....
danke an die helfer.... wollt hier nurnoch mal die lösung posten:

public Li<Li<A>> tails()
  {
	  Li<Li<A>> result = new LiImpl<Li<A>>();
	  
	  for(int i=0; i < this.length(); i++)
	  {	  
		  result = new LiImpl<Li<A>>(drop(i), result);
	  }
	  
	  return result.reverse();
  }

 

[Thomas Darimont]

Hallo,

wieso nicht einfach so?:

/**
 * 
 */
package de.tutorials;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author Thomas.Darimont
 *
 */
public class ListTailsExample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List<List<String>> tails = tails(Arrays.asList("this","is","a","test"));
        System.out.println(tails);
    }

    private static <T> List<List<T>> tails(List<T> list) {
        List<List<T>> tails = new ArrayList<List<T>>();
        for(int i = 0, size = list.size();i< size;i++){
            tails.add(list.subList(i, size));
        }
        return tails;
    }
}

Gruß Tom

 

[zeja]

Na das sollte doch ne eigene Implementierung sein, Tom

Aber mit der Implementierung wird die Originalliste verändert und ich denke nicht, dass das so sein sollte psychoDe.