NP - Lab 5

/*Супер-стринг Problem 1
Треба да се напише класа SuperString. Класата во позадина претставува листа на стрингови LinkedList<String> и ги нуди следните методи:

SuperString() - креира празен стринг
append(String s) - го додава стрингот на крајот во листата
insert(String s) - го додава стрингот на почеток на листата
contains(String s):boolean - враќа true доколку стрингот s се наоѓа во супер-стрингот. Стрингот s може да е разделен во повеќе подстрингови во листата. Пр: list = [ "st" , "arz" , "andrej" ] , contains("tarzan") –> true
reverse() - го превртува стрингот на следниов начин. Ги превртува сите елементи во листата, а потоа и секој подстринг како елемент посебно го превртува. list = [ "st" , "arz" , "andrej: ]; reverse(); list = [ "jerdna", "zra", "ts"]
toString():String - ги враќа конкатенирани сите елементи во листата list = [ "st" , "arz" , "andrej"]; toString() -> "starzandrej"
removeLast(int k) – ги отстранува последнo додадените k подстрингови*/

import java.util.Scanner;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

class SuperString {
    private LinkedList<String> lista;
    private LinkedList<String> stringList;
    public void append(String next) {
        lista.add(next);
        stringList.push(next);
    }

    public void insert(String next) {
        lista.addFirst(next);
        stringList.push(next);
    }

    @Override
    public String toString() {

        return lista.toString();
    }

    public boolean contains(String next) {
        String cont = lista.toString();
        return cont.contains(next);
    }

    public void reverse() {

            LinkedList<String> newList = new LinkedList<>();
            lista.forEach(newList::addFirst);
            List<String> reversedList = newList.stream()
                    .map(word -> new StringBuilder(word).reverse().toString())
                    .collect(Collectors.toList());

            LinkedList<String> vratiNazad = new LinkedList<String>(){
            public String toString()
            {
                StringBuilder sb = new StringBuilder();
                for (String aLista : lista) sb.append(aLista);
                return sb.toString();
            }
        };
            for(int i=0;i<reversedList.size();i++)
            vratiNazad.addLast(reversedList.get(i));
            lista = vratiNazad;
        LinkedList<String> newHelper = new LinkedList<>();
        stringList.forEach(newHelper::addFirst);

        List<String> helperList = newHelper
                .stream()
                .map(word -> new StringBuilder(word).reverse().toString())
                .collect(Collectors.toList());

        stringList.clear();
        helperList.forEach(stringList::addFirst);


    }

    public SuperString() {
        lista = new LinkedList<String>(){
            public String toString()
            {
                StringBuilder sb = new StringBuilder();
                for (String aLista : lista) sb.append(aLista);
                return sb.toString();
            }
        };
        stringList = new LinkedList<String>();
    }

    public void removeLast(int i) {
        for(int j=0;j<i;j++)
        lista.remove(stringList.pop());
    }
}


public class SuperStringTest {

    public static void main(String[] args) {
        Scanner jin = new Scanner(System.in);
        int k = jin.nextInt();
        if (  k == 0 ) {
            SuperString s = new SuperString();
            while ( true ) {
                int command = jin.nextInt();
                if ( command == 0 ) {//append(String s)
                    s.append(jin.next());
                }
                if ( command == 1 ) {//insert(String s)
                    s.insert(jin.next());
                }
                if ( command == 2 ) {//contains(String s)
                    System.out.println(s.contains(jin.next()));
                }
                if ( command == 3 ) {//reverse()
                    s.reverse();
                }
                if ( command == 4 ) {//toString()
                    System.out.println(s);
                }
                if ( command == 5 ) {//removeLast(int k)
                    s.removeLast(jin.nextInt());
                }
                if ( command == 6 ) {//end
                    break;
                }
            }
        }
    }

}

/*Листа на цели броеви Problem 2 (1 / 13)
Со користење на ArrayList или LinkedList сакаме да развиеме класа за работа со листи од цели броеви IntegerList. Листата ги има следните вообичаени методи:

IntegerList() - конструктор кој креира празна листа.
IntegerList(Integer… numbers) - конструктор коj креира листа што ги содржи елементите numbers во истиот редослед во кој тие се појавуваат во низата.
add(int el, int idx) - го додава елементот на соодветниот индекс. Доколку има други елементи после таа позиција истите се поместуваат на десно за едно место (нивните индекси им се зголемуваат за 1). Доколку idx е поголемо од сегашната големина на листата ја зголемуваме листата и сите нови елементи ги иницијалираме на нула (освен тој на позиција idx кој го поставуваме на el).
remove(int idx):int - го отстранува елементот на дадена позиција од листата и истиот го враќа. Доколку после таа позиција има други елементи истите се поместуваат во лево (нивните индекси се намалуваат за 1).
set(int el, int idx) - го поставува елементот на соодветната позиција.
get(int idx):int - го враќа елементот на соодветната позиција.
size():int - го враќа бројот на елементи во листата.
Освен овие методи IntegerList треба да нуди и неколку методи згодни за работа со цели броеви:

count(int el):int - го враќа бројот на појавувања на соодветниот елемент во листата.
removeDuplicates() - врши отстранување на дупликат елементите од листата. Доколку некој елемент се сретнува повеќе пати во листата ја оставаме само последната копија од него. Пр: 1,2,4,3,4,5. -> removeDuplicates() -> 1,2,3,4,5
sumFirst(int k):int - ја дава сумата на првите k елементи.
sumLast(int k):int - ја дава сумата на последните k елементи.
shiftRight(int idx, int k) - го поместува елементот на позиција idx за k места во десно. При поместувањето листата ја третираме како да е кружна. Пр: list = [1,2,3,4]; list.shiftLeft(1,2); list = [1,3,4,2] - (листата е нула индексирана така да индексот 1 всушност се однесува на елементот 2 кој го поместуваме две места во десно) list = [1,2,3,4]; list.shiftLeft(2, 3); list = [1,3,2,4] - елементот 3 го поместуваме 3 места во десно. По две поместувања стигнуваме до крајот на листата и потоа продолжуваме да итерираме од почетокот на листата уште едно место и овде го сместуваме.
shiftLeft(int idx , int k) - аналогно на shiftRight.
addValue(int value):IntegerList - враќа нова листа каде елементите се добиваат од оригиналната листа со додавање на value на секој елемент. Пр: list = [1,4,3]; addValue(5) -> [6,9,8]
Забелешка која важи за сите методи освен add: Ако индексот е негативен или поголем од тековната големина на листата фрламе исклучок ArrayIndexOutOfBoundsException.*/

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.stream.Collectors;

class IntegerList{
    private ArrayList<Integer> list;

    IntegerList(){
        list = new ArrayList<>();
    }

    IntegerList(Integer... numbers){
        list = new ArrayList<>(Arrays.asList(numbers));
    }

    void add(int el, int idx){
        if (idx>list.size()){
            int n = idx-list.size();
            for(int i=0;i<n;i++){
                list.add(0);
            }
            list.add(el);
        }
        else list.add(idx,el);
    }

    void remove(int idx){
        validateIndex(idx);
        list.remove(idx);
    }

    void set(int el, int idx){
        validateIndex(idx);
        list.set(idx,el);
    }

    int get(int idx){
        validateIndex(idx);
        return list.get(idx);
    }

    int size(){
        return list.size();
    }

    int count(int el){
        return (int) list.stream()
                .filter(n -> n.equals(el))
                .count();
    }

    void removeDuplicates(){
        for (int i = 0; i < list.size(); i++) {
            //System.out.println(arrayList.toString());
            Integer integer = list.get(i);
            for (int j = 0; j < i; j++) {
                if (integer.equals(list.get(j))) {
                    list.remove(j);
                    i--;
                    break;
                }
            }
        }
    }

    int sumFirst(int k){
        return list.stream().limit(k).mapToInt(Integer::valueOf).sum();
    }

    int sumLast(int k){
        return list.subList(list.size()-k,list.size()).stream().mapToInt(Integer::valueOf).sum();
    }

    void shiftRight(int idx, int k){
        validateIndex(idx);
        int shIdx = (idx+k) % list.size();
        Integer num = list.get(idx);
        list.remove(idx);
        list.add(shIdx,num);
    }

    void shiftLeft(int idx, int k){
        validateIndex(idx);
        int shIdx = (idx-k) % list.size();
        if(shIdx<0) shIdx+=list.size();
        Integer num = list.get(idx);
        list.remove(idx);
        list.add(shIdx,num);
    }

    IntegerList addValue(int value){
        ArrayList<Integer> tmp =list.stream().map(n->n+value).collect(Collectors.toCollection(ArrayList::new));
        return new IntegerList(tmp);
    }

    IntegerList(ArrayList<Integer> nums){
        list = nums;
    }

    void validateIndex(int idx){
        if(idx<0 || idx>=list.size()) throw new ArrayIndexOutOfBoundsException();
    }
}

public class IntegerListTest {

    public static void main(String[] args) {
        Scanner jin = new Scanner(System.in);
        int k = jin.nextInt();
        if ( k == 0 ) { //test standard methods
            int subtest = jin.nextInt();
            if ( subtest == 0 ) {
                IntegerList list = new IntegerList();
                while ( true ) {
                    int num = jin.nextInt();
                    if ( num == 0 ) {
                        list.add(jin.nextInt(), jin.nextInt());
                    }
                    if ( num == 1 ) {
                        list.remove(jin.nextInt());
                    }
                    if ( num == 2 ) {
                        print(list);
                    }
                    if ( num == 3 ) {
                        break;
                    }
                }
            }
            if ( subtest == 1 ) {
                int n = jin.nextInt();
                Integer a[] = new Integer[n];
                for ( int i = 0 ; i < n ; ++i ) {
                    a[i] = jin.nextInt();
                }
                IntegerList list = new IntegerList(a);
                print(list);
            }
        }
        if ( k == 1 ) { //test count,remove duplicates, addValue
            int n = jin.nextInt();
            Integer a[] = new Integer[n];
            for ( int i = 0 ; i < n ; ++i ) {
                a[i] = jin.nextInt();
            }
            IntegerList list = new IntegerList(a);
            while ( true ) {
                int num = jin.nextInt();
                if ( num == 0 ) { //count
                    System.out.println(list.count(jin.nextInt()));
                }
                if ( num == 1 ) {
                    list.removeDuplicates();
                }
                if ( num == 2 ) {
                    print(list.addValue(jin.nextInt()));
                }
                if ( num == 3 ) {
                    list.add(jin.nextInt(), jin.nextInt());
                }
                if ( num == 4 ) {
                    print(list);
                }
                if ( num == 5 ) {
                    break;
                }
            }
        }
        if ( k == 2 ) { //test shiftRight, shiftLeft, sumFirst , sumLast
            int n = jin.nextInt();
            Integer a[] = new Integer[n];
            for ( int i = 0 ; i < n ; ++i ) {
                a[i] = jin.nextInt();
            }
            IntegerList list = new IntegerList(a);
            while ( true ) {
                int num = jin.nextInt();
                if ( num == 0 ) { //count
                    list.shiftLeft(jin.nextInt(), jin.nextInt());
                }
                if ( num == 1 ) {
                    list.shiftRight(jin.nextInt(), jin.nextInt());
                }
                if ( num == 2 ) {
                    System.out.println(list.sumFirst(jin.nextInt()));
                }
                if ( num == 3 ) {
                    System.out.println(list.sumLast(jin.nextInt()));
                }
                if ( num == 4 ) {
                    print(list);
                }
                if ( num == 5 ) {
                    break;
                }
            }
        }
    }

    public static void print(IntegerList il) {
        if ( il.size() == 0 ) System.out.print("EMPTY");
        for ( int i = 0 ; i < il.size() ; ++i ) {
            if ( i > 0 ) System.out.print(" ");
            System.out.print(il.get(i));
        }
        System.out.println();
    }

}