Sada úkolů pro předmět DSA

Sada úkolů pro předmět DSA A7B36DSA http://neuron.felk.cvut.cz/dsa/index.html Ing. Martin Chlumecký Katedra počítačů ČVUT v Praze, FEL Evropský sociální fond Praha & EU: Investujeme do vaší budoucnosti

Evropský sociální fond Praha & EU: Investujeme do vaší budoucnosti Domácí úkoly z předmětu DSA Domácí úkoly Domácí úkoly mají dvě varianty: lehčí a těžší. Lehčí varianta je za jeden bod, těžší vzhledem k větší míře samostatné práce za čtyři body. U řešitelů těžších domácích úkolů se předpokládá znalost Featherweight Javy. Přístupové údaje k repozitáři URL vašeho repozitáře je https://cvut.repositoryhosting.com/svn/cvut_<login>/ URL pro brouzdání po vašem repozitáři na webu je https://cvut.repositoryhosting.com/trac/cvut_<login>/browser Login je vaše uživatelské jméno v síti ČVUT Počáteční heslo je shodné s vaším uživatelským jménem (není se sítí ČVUT synchronizováno) URL pro přihlášení do administračního rozhraní na webu je https://cvut.repositoryhosting.com

Zadání lehčích domácích úkolů Lehčí domácí úkoly odevzdávejte přes repozitář. Každý úkol umístěte do adresáře homeworks a souboru homework<n>.java, kde <n> je číslo úkolu. Všechny odevzdávané třídy dělejte neveřejné (aby mohly být v jednom souboru) a neumísťujte je do žádného balíčku. Kromě vašeho kódu neodevzdávejte nic jiného - třídy a rozhraní, která jsou součástí zadání, si k vašemu kódu přilinkujeme sami. Pokud chcete ve zdrojácích používat češtinu, používejte kódování ISO8859-2. Pokud se ještě s testovacím systémem objeví problémy, dejte o nich (mailem) vědět přednášejícímu nebo cvičícím - jinak se nápravy nedočkáte. První Naimplementujte třídu Homework1 implementující rozhraní Mergesort. interface Mergesort { int[] getfirsthalfof(int[] array); // vrati nesetridenou kopii prvni poloviny (horni celou cast) pole array int[] getsecondhalfof(int[] array); // vrati nesetridenou kopii druhe poloviny (dolni celou cast) pole array int[] merge(int[] firsthalf, int[] secondhalf); // slije prvky v firsthalf a secondhalf do jednoho pole a vrati ho int[] mergesort(int[] array); // vrati setridenou kopii pole array Druhý Naimplementujte třídu Homework2 implementující rozhraní Matrix. Násobení matic musí být implementováno Strassenovým algoritmem, tzn. metoda times volaná na netriviální matici (matici větší než 1 1) musí svůj výsledek získat pouze pomocí volání metod plus, minus a times na podmaticích. Všechny vaše metody by měly fungovat s jakoukoli korektní implementací rozhraní Matrix. /** Rozhrani Matrix reprezentuje ctvercovou matici, jejiz rozmer je mocnina dvojky. interface Matrix { /* Vrati rozmer matice. int getsize(); /* Vrati prvek na indexu n, m (1 <= n <= getsize(), 1 <= m <= getsize()). int getelement(int n, int m); /* Vrati levou horni podmatici. Matrix gettopleftsubmatrix(); /* Vrati pravou horni podmatici. public Matrix gettoprightsubmatrix(); /* Vrati levou dolni podmatici. public Matrix getbottomleftsubmatrix(); /* Vrati pravou dolni podmatici. public Matrix getbottomrightsubmatrix(); /* Vrati soucet matic this a other (muzete predpokladat, ze this.getsize() == other.getsize()).

public Matrix plus(matrix other); /* Vrati rozdil matic this a other (muzete predpokladat, ze this.getsize() == other.getsize()). public Matrix minus(matrix other); /* Vrati soucin matic this a other (muzete predpokladat, ze this.getsize() == other.getsize()). public Matrix times(matrix other); class Homework2 implements Matrix { /** Vytvori novou matici (muzete predpokladat, ze contents je ctvercove pole, jehoz rozmer je mocnina dvojky). public Homework2(int[][] contents) { /*... /* Zbytek tridy Homework2. Třetí Naimplementujte třídu Homework3 implementující rozhraní HeapStorage a třídu Heap. Za korektní implementaci třídy Homework3 získáte jeden bod, za korektní implementaci třídyheap další. interface DSAComparable<E> { /** Vrati true, pokud je this (ostre) mensi nez other, false jinak. boolean less(e other); /** Vrati nejmensi prvek ze vsech prvku typu E (tzn. prvek, ktery je mensi nez * jakykoli jiny prvek typu E). Vracena hodnota nezavisi na this, jen na E. E getleastelement(); /** Vrati nejvetsi prvek ze vsech prvku typu E (tzn. prvek, ktery je vetsi * nez jakykoli jiny prvek typu E). Vracena hodnota nezavisi na this, jen na E. E getgreatestelement(); /** Rozhrani HeapStorage reprezentuje pole, do ktereho si halda uklada svoje prvky. interface HeapStorage<E extends DSAComparable<E>> { /** Vrati aktualni velikost HeapStorage. int getsize(); /** Vrati true, pokud je aktualni velikost HeapStorage nulova. boolean isempty(); /** Vrati prvek na indexu index (1 <= index <= getsize()). Pokud je index

* mensi nebo roven nule, vrati nejvetsi prvek. Pokud je index vetsi nez * velikost pole, vrati nejmensi prvek. V obou pripadech muzete predpokladat, * ze v HeapStorage je alespon jeden prvek. E getelement(int index); /** Prohodi prvky na indexech index a index2 (1 <= index, index2 <= getsize()). void swap(int index, int index2); /** Odstrani posledni prvek (tzn. snizi velikost teto HeapStorage) a vrati jeho hodnotu. E extractlast(); /** Vlozi prvek a vrati jeho index. Muzete predpokladat, ze ve spodnim poli je dost mista. int insertlast(e element); class Homework3<E extends DSAComparable<E>> implements HeapStorage<E>{ /** Vytvori novy objekt HeapStorage nad polem elements, jeho velikost je stejna jako delka pole. Homework3(E[] elements) { /* kod /* metody /** Trida Heap reprezentuje haldu (s maximem ve vrcholu). class Heap<E extends DSAComparable<E>> { HeapStorage<E> storage; /** Vytvori haldu nad danym HeapStorage (tzn. zavola algoritmus build heap). Heap(HeapStorage<E> storage) { /* kod /** Zavola algoritmus heapify nad uzlem na indexu index. void heapify(int index) { /* kod /** Vlozi do haldy novy prvek. Muzete predpokladat, ze v poli uvnitr HeapStorage na nej misto je. void insert(e element) { /* kod

/** Odstrani a vrati z haldy maximalni prvek. E extractmax() { /* kod /** Vrati true, pokud je halda prazdna. boolean isempty() { /* kod /** Pomoci algoritmu trideni haldou vzestupne setridi pole array. static <E extends DSAComparable<E>> void heapsort(e[] array) { /* kod Soutěž Pokud chcete, můžete se zúčastnit soutěže o nejelegantnější implementaci třetího domácího úkolu. Kritéria elegance jsou zejména: srozumitelnost kódu, jeho kompaktnost a jeho snadná modifikovatelnost. Pro přihlášení do soutěže pošlete email přednášejícímu, uzávěrka přihlášek je shodná s datem odevzdání úkolu, tj. 14. 11. O vítězi rozhodně porota složená z cvičících předmětu, hlavní cena je bod za aktivitu. Čtvrtý Naimplementujte třídu DSAHashTable (kvůli omezení Javy musíte generické pole alokovat takto: (Set<Pair<K, V> >[]) new Set<?>[size]). import java.util.iterator; import java.util.set; /** Trida Pair reprezentuje dvojici (klic, hodnota). class Pair<K,V> { K key; V value;

Pair(K k, V v) { key = k; value = v; public int hashcode() { return key.hashcode() + 3 * value.hashcode(); public boolean equals(object other) { if (! (other instanceof Pair<?,?>)) return false; Pair<?,?> o = (Pair<?,?>) other; return key.equals(o.key) && value.equals(o.value); /** Trida DSAHashTable reprezentuje rozptylovaci tabulku se zřetězením (první varianta v učebnici). class DSAHashTable<K,V> { /** Vytvori prazdnou instanci DSAHashTable, delka vnitrniho pole je nastavena na size, obsah vnitrniho pole * je inicializovan na prazdne mnoziny. DSAHashTable(int size) { /* kod /** Ulozi dvojici (key, value) do rozptylovaci tabulky. Pokud uz v tabulce je jina dvojice se stejnym klicem, * je smazana. Klic ani hodnota nesmi byt null. Pokud by pocet dvojic v tabulce po vykonani put mel vzrust nad * dvojnasobek delky vnitrniho pole, vnitrni pole zdvojnasobi. void put(k key, V value) { /* kod /** Vrati hodnotu asociovanou s danym klicem nebo null, pokud dany klic v tabulce neni. V get(k key) { /* kod /** Smaze dvojici s danym klicem. Pokud v tabulce dany klic neni, nedela nic. void remove(k key) { /* kod /** Vrati vnitrni pole. Prvni vnitrniho pole mohou byt instance trid v balicku java.util, tzn. nemusite psat * vlastni implementaci rozhrani java.util.set. Set<Pair<K,V>>[] getarray() { /* kod /** Pro dany klic vrati index v poli. Jako hashovaci funkce se pouzije key.hashcode. int getindexof(k key) { /* kod /** Pokud je pocet prvku mensi nebo roven dvojnasobku delky vnitrniho pole, vrati true, jinak vrati false. boolean isbigenough() { /* kod /** Zmeni delku vnitrniho pole, nainicializuje jej prazdnymi mnozinami a zkopiruje do nej vsechny dvojice. void resize(int newsize) { /* kod

/** Vrati iterator pres vsechny dvojice v tabulce. Iterator nemusi mit implementovanou metodu remove. Iterator<Pair<K,V>> iterator() { /* kod Pátý Naimplementujte třídu Tree. import java.util.iterator; interface DSAComparable<E extends DSAComparable<E>> { boolean lessorequal(e other); boolean greater(e other); boolean equal(e other); class Node<E extends DSAComparable<E>> { E contents; private Node<E> parent; Node<E> left, right; /** Vrati naslednika (tzn. uzel obsahujici nejblizssi vyssi hodnotu) tohoto uzlu. Node<E> succ() { if (right!= null) { Node<E> temp = right; while (temp.left!= null) temp = temp.left; return temp; else { Node<E> temp = this; Node<E> parent = this.parent; while (parent!= null && parent.right == temp) { parent = parent.parent; temp = temp.parent; return parent; Node(E elem, Node<E> parent) { this.contents = elem; this.parent = parent;

void setparent(node<e> p) { parent = p; /** * Trida Tree reprezentuje binarni vyhledavaci strom, ve kterem pro kazdy uzel n plati * n.left == null n.left.contents.lessorequal(n.contents) a * n.right == null n.right.contents.greater(n.contents). class Tree<E extends DSAComparable<E>> { Node<E> root; /** Vrati minimum z tohoto stromu nebo null, pokud je strom prazdny. E minimum() { /* kod /** Vrati minimum ze zadaneho podstromu nebo null, pokud je podstrom prazdny. E subtreemin(node<e> n) { /* kod /** Vrati maximum z tohoto podstromu nebo null, pokud je strom prazdny. E maximum() { /* kod /** Vrati maximum ze zadaneho podstromu nebo null, pokud je podstrom prazdny. E subtreemax(node<e> n) { /* kod /** Vlozi prvek do stromu, pripadne duplicity ponechava (tzn. stejny prvek muze * byt ve stromu vickrat). void insert(e elem) { /* kod /** * Projde strom smerem za uzlem s hodnotou elem a vrati: * - uzel s hodnotou elem, pokud existuje, * - posledni potkany koncovy uzel (=uzel s maximalne jednim potomkem), pokud uzel s hodnotou elem neexistuje nebo * null pokud je cely strom prazdny. Node<E> find(e elem) { /* kod /** Vrati true, pokud tento strom obsahuje prvek elem. boolean contains(e elem) { /* kod /** Odstrani jeden vyskyt prvku elem z tohoto stromu. void remove(e elem) { /* kod /** Vrati iterator pres cely strom (od nejmensiho po nejvetsi). Iterator<E> iterator() { /* kod /** Vrati iterator prochazejici pres interval [lowerbound, higherbound] vcetne. Iterator<E> boundediterator(e lowerbound, E higherbound) { /* kod /** Vrati korenovy uzel tohoto stromu. Node<E> getrootnode() { /* kod

Šestý Dynamické programování je vlastně rekurze zkřížená s memoizací. Samotný rekurzivní popis algoritmu je pro každou úlohu jiný, ale memoizace je pořád stejná - řešení podúloh se zaznamenává do tabulky a znovupoužívá, když je potřeba. Vaším úkolem je naprogramovat metodu Machine.solve, ve které bude právě ta memoizace. Metodasolve by při zavolání měla: 1. mrknout do tabulky a pokud v ní řešení už je, vrátit ho, 2. pokud v tabulce řešení není, měla by si ze zadané úlohy vytáhnout možná podřešení a vybrat to nejlepší (s nejvyšší hodnotou) a 3. před vrácením nejlepšího řešení by si ho měla uložit do tabulky. import java.util.hashmap; import java.util.hashset; import java.util.map; import java.util.set; /** Trida Pair reprezentuje dvojici. class Pair<First, Second> { First first; Second second; Pair(First f, Second s) { first = f; second = s; First getfirst() { return first; Second getsecond() { return second; /** Instance rozhrani Task reprezentuji optimalizacni ulohu. interface Task<T extends Task<T, S, W>, S extends Solution<T, S, W>, W extends Comparable<W>> { /** Vrati vsechna mozna (ne nutne optimalni) reseni teto ulohy. Vzdy vrati alespon jedno reseni. Set<S> getpossiblesolutions(); /** Instance rozhrani Solution reprezentuji reseni nejake konkretni optimalizacni ulohy.

interface Solution<T extends Task<T, S, W>, S extends Solution<T, S, W>, W extends Comparable<W>> { /** Vrati hodnotu tohoto reseni. W getworth(machine<t, S, W> m); class Machine<T extends Task<T, S, W>, S extends Solution<T, S, W>, W extends Comparable<W>> { Map<T, Pair<S, W>> cache = new HashMap<T, Pair<S, W>>(); Pair<S, W> solve(t task) { /* kod class RodTask implements Task<RodTask, RodSolution, Integer> { final int length; final int[] table; final Set<RodSolution> sols = new HashSet<RodSolution>(); static int instancecount; RodTask(int length, int[] table) { this.length = length; this.table = table; for (int i = 1; i <= length; i++) sols.add(new RodSolution(i, length - i, table)); instancecount++; public Set<RodSolution> getpossiblesolutions() { return sols; public int hashcode() { int code = length; for (int i : table) code += 3 * i; return code; public boolean equals(object o) { if (!(o instanceof RodTask)) return false; RodTask other = (RodTask) o; if (length!= other.length table.length!= other.table.length) return false; for (int i = 0; i < table.length; i++) if (table[i]!= other.table[i]) return false;

return true; class RodSolution implements Solution<RodTask, RodSolution, Integer> { final int first; final int rest; final int[] table; RodSolution(int first, int rest, int[] table) { this.first = first; this.rest = rest; this.table = table; public Integer getworth(machine<rodtask, RodSolution, Integer> m) { int worth = table[first]; if (rest > 0) worth += m.solve(new RodTask(rest, table)).getsecond(); return worth; Sedmý Naprogramujte B-strom. import java.util.list; /** Instance tridy Tree reprezentuji B-strom. class Tree { /** Koren tohoto stromu. Node root; /* atributy /** Vytvori prazdny B-strom se zadanou kapacitou uzlu. Kapacita uzlu je * maximalni pocet klicu, ktere se v jednom uzlu mohou objevit. Tree(int nodecapacity) { /* kod

/** Indikuje, jestli tento strom obsahuje zadany klic. boolean contains(integer key) { /* kod /** Prida zadany klic do stromu. Pokud tento strom zadany klic uz obsahuje, * neudela nic. void add(integer key) { /* kod /** Odebere zadany klic ze stromu. Pokud tento strom zadany klic neobsahuje, * neudela nic. void remove(integer key) { /* kod /* kod class Node { /* atributy /** Vrati klice ulozene v tomto uzlu serazene vzestupne. List<Integer> getkeys() { /* kod /** Vrati ukazatele na podstromy ulozene v tomto uzlu serazene v poradi odpovidajicim * poradi klicu. Pozor: vzdy musi platit, ze pocet_ukazatelu_na_podstromy = pocet_klicu + 1, * u listovych uzlu proto musite vracet seznam nullu. List<Node> getsubtrees() { /* kod Zadání těžších domácích úkolů První

Ve Featherweight Javě naimplementujte datovou strukturu v C. Okasaki: Purely Functional Data Structures označovanou jako persistent binary random-access list. Pro počáteční nasměrování a dodatečné informace kontaktujte přednášejícího. Základní knihovnu FJ z minulého semestru najdete nahttps://cvut.repositoryhosting.com/trac/cvut_lectures/browser/lecture14/src/lecture14/lecture14.java Druhý Naimplementujte níže uvedené třídy a rozhraní a s jejich pomocí napište následující algoritmy: řazení vkládáním, řazení sléváním, quicksort, quick seleck a řazení haldou. Pokud bude potřeba, můžete níže uvedenou strukturu tříd obohatit o nové metody nebo mírně změnit, ale měli byste zachovat stejného ducha. /** Instance implementujici toto rozhrani reprezentuji multimnozinu, * ktera se po vytvoreni uz nezmeni. interface ImmutableMultiset<E> { /** Vrati sjednoceni teto a zadane multimnoziny. ImmutableMultiset<E> union(immutablemultiset<e> other); /** Vrati rozdil teto a zadane multimnoziny. ImmutableMultiset<E> difference(immutablemultiset<e> other); /** Vrati, zda tato multimnozina obsahuje zadany prvek. ImmutableBoolean contains(e elem); /** Vrati velikost teto multimnoziny. ImmutableInteger size(); /** Instance teto tridy reprezentuji prazdnou multimnozinu. class EmptyMultiset<E> implements ImmutableMultiset<E> { static <E> EmptyMultiset<E> createemptymultiset(); /** Instance teto tridy reprezentuji multimnozinu s jednim prvkem. class SingletonMultiset<E> implements ImmutableMultiset<E> { static <E> SingletonMultiset<E> createsingletonmultiset(e elem); /** Instance teto tridy reprezentuji sjednoceni dvou multimnozin. class Union<E> implements ImmutableMultiset<E> { static <E> Union<E> createunion(immutablemultiset<e> first, ImmutableMultiset<E> second);

/** Instance teto tridy reprezentuji rozdil dvou multimnozin. class Difference<E> implements ImmutableMultiset<E> { static <E> Difference<E> createdifference(immutablemultiset<e> first, ImmutableMultiset<E> second); /** Instance implementujici toto rozhrani reprezentuji sekvenci, * ktera se po vytvoreni uz nezmeni. interface ImmutableSequence<E> { /** Vrati spojeni teto a zadane sekvence. ImmutableSequence<E> concat(immutablesequence<e> other); /** Vrati podsekvenci zadane sekvence. Prvni prvek sekvence ma index nula. ImmutableSequence<E> subsequence(immutableinteger from, ImmutableInteger to); /** Vrati delku teto sekvence. ImmutableInteger size(); /** Vrati prvek na zadanem indexu. Prvni prvek ma index nula. E elementat(immutableinteger position); /** Instance teto tridy reprezentuji prazdnou sekvenci. class EmptySequence<E> implements ImmutableSequence<E> { static <E> EmptySequence<E> createemptysequence(); /** Instance teto tridy reprezentuji sekvenci delky jedna. class SingletonSequence<E> implements ImmutableSequence<E> { static <E> SingletonSequence<E> createsingletonsequence(e elem); /** Instance teto tridy reprezentuji spojeni dvou sekvenci. class Concatenation<E> implements ImmutableSequence<E> { static <E> Concatenation<E> createconcatenation(sequence<e> first, Sequence<E> second); /** Instance teto tridy reprezentuji podsekvenci nejake sekvence. class Subsequence<E> implements ImmutableSequence<E> { static <E> Subsequence<E> createsubseqence(sequence<e> seq, ImmutableInteger from, ImmutableInteger to); /** Instance teto tridy reprezentuji cele cislo, ktere se po vytvoreni jiz nezmeni. interface ImmutableInteger { /** Vrati soucet tohoto a zadaneho cisla. ImmutableInteger plus(immutableinteger other);

/** Vrati rozdil tohoto a zadaneho cisla. ImmutableInteger minus(immutableinteger other); /** Vrati soucin tohoto a zadaneho cisla. ImmutableInteger times(immutableinteger other); /** Vrati podil tohoto a zadaneho cisla. ImmutableInteger dividedby(immutableinteger other); /** Indikuje, zda je toto cislo mensi, nez zadane. ImmutableBoolean less(immutableinteger other); /** Indikuje, zda je toto cislo shodne jako zadane. ImmutableBoolean equal(immutableinteger other); /** Indikuje, zda je toto cislo vetsi, nez zadane. ImmutableBoolean greater(immutableinteger other); /** Instance teto tridy reprezentuji konstantu. class Constant implements ImmutableInteger { static Constant createconstant(int c); /** Instance teto tridy reprezentuji soucet dvou cisel. class Plus implements ImmutableInteger { static Plus createplus(immutableinteger first, ImmutableInteger second); /** Instance teto tridy reprezentuji rozdil dvou cisel. class Minus implements ImmutableInteger { static Minus createminus(immutableinteger first, ImmutableInteger second); /** Instance teto tridy reprezentuji soucin dvou cisel. class Product implements ImmutableInteger { static Product createproduct(immutableinteger first, ImmutableInteger second); /** Instance teto tridy reprezentuji podil dvou cisel. class Division implements ImmutableInteger { static Division createdivision(immutableinteger first, ImmutableInteger second); /** Instance implementujici toto rozhrani reprezentuji pravdivostni hodnotu, * ktera se po vytvoreni jiz nezmeni. interface ImmutableBoolean {

/** Vrati negaci teto hodnoty. ImmutableBoolean not(); /** Vrati konjunkci teto a zadane hodnoty. ImmutableBoolean and(immutableboolean other); /** Vrati disjunkci teto a zadane hodnoty. ImmutableBoolean or(immutableboolean other); /** Instance teto tridy reprezentuji pravdu. class True implements ImmutableBoolean { static True createtrue(); /** Instance teto tridy reprezentuji nepravdu. class False implements ImmutableBoolean { static False createfalse(); /** Instance teto tridy reprezentuji negaci nejake pravdivostni hodnoty. class Negation implements ImmutableBoolean { static Negation createnegation(); /** Instance teto tridy reprezentuji konjunkci dvou pravdivostnich hodnot. class Conjunction implements ImmutableBoolean { static Conjunction createconjunction(immutableboolean other); /** Instance teto tridy reprezentuji disjunkci dvou pravdivostnich hodnot. class Disjunction implements ImmutableBoolean { static Disjunction createdisjunction(immutableboolean other); /** Instance teto tridy reprezentuji multimnozinu. Obsah multimnoziny je reprezentovan * v promenne inner. class DSAMultiset<E> { ImmutableMultiset<E> inner; /* Vytvori a vrati prazdnou multimnozinu. static DSAMultiset createemptymultiset(); /* Vytvori a vrati multimnozinu s jednim prvkem. static <E> DSAMultiset<E> createsingletonmultiset(e elem); /* Prida zadany prvek do teto multimnoziny.

void add(e elem); /* Prida vsechny prvky v zadane multimnozine do teto multimnoziny. void addall(dsamultiset<e> ms); /* Odstrani zadany prvek z teto multimnoziny. void remove(e elem); /* Odstrani vzechny prvky v zadane multimnozine z teto multimnoziny. void removeall(dsamultiset<e> elem); /* Vyrobi kopii teto multimnoziny. DSAMultiset<E> clone(); /* Vrati velikost teto multimnoziny. ImmutableInteger size(); /* Indikuje, zda tato mnozina obsahuje zadany prvek. ImmutableBoolean contains(e elem); /** Instance teto tridy reprezentuji sekvenci. Obsah sekvence je reprezentovan * v promenne inner. class DSASequence<E> { ImmutableSequence<E> inner; /* Vytvori a vrati prazdnou sekvenci. static DSASequence createemptysequence(); /* Vytvori a vrati multimnozinu o delce jedna. static <E> DSASequence<E> createsingletonsequence(e elem); /* Pripoji zadanou sekvenci do teto sekvence. DSASequence<E> append(dsasequence<e> other); /* Pripoji zadanou sekvenci na zacatek teto sekvence. DSASequence<E> prepend(dsasequence<e> other); /* Vrati podsekvenci teto sekvence (jako nezavisly objekt). DSASequence<E> subseq(immutableinteger from, ImmutableInteger to); /* Vrati velikost teto sekvence. ImmutableInteger size(); /* Vrati prvek na zadanem indexu, prvni prvek ma index nula. E elementat(immutableinteger elem);