Računalništvo 1 (PRA)

import java.io.*;
import java.util.*;

public class Naloga3 {

  // Vaja 3
  // Napravimo (statično) metodo, ki kot argument dobi ime vhodne
  // datoteke. Vse vrstice vhodne datoteke prebere v objekt razreda
  // Vector, ki ga vrne kot vrednost. Vsako vrstico iz vhodne
  // datoteke vstavimo v vektor tako, da bodo elementi v vektorju
  // sortirani po abecedi.
  public static Vector beriS(String ime) throws IOException {
  // skelet metode je enak kot pri vaji 1
    BufferedReader dat = new BufferedReader(new FileReader(ime));
    Vector vv = new Vector();
    while (dat.ready()) {
      String ll = dat.readLine();
      // Tu imamo prebrano vrstico ll
      // Odlociti se moramo, kam v Vector vv jo bomo vstavili.
      // Predpostavljamo, da so vsi dosedanji elementi vv že
      // sortirani, kar pomeni, da moramo poiskati tisti kk, kjer
      // je (prvič)  ll <= vv.elementAt(kk).
      // To naredimo tako, da s kk štejemo od 0 do vv.size()-1 in
      // vsakokrat testiramo gornji pogoj; ko najdemo kk, ki ustreza
      // gornjemu pogoju, vstavimo podatek ll v vektor vv in končamo
      // zanko.
      // Posebni (robni) problemi:
      // 1. vektor je prazen: gornji pogoj ne more biti nikoli
      //    izpolnjen, saj ni nobenega elementa - v resnici se zanka
      //    ne bo nikoli izvedla in se bo "naravno" iztekla (brez
      //    break); nov podatek moramo dodati na konec vektorja
      //    (uporabiti vv.add(ll)).
      // 2. podatek je večji od vseh dosedanjih: zanka se bo iztekla,
      //    ker gornji pogoj ni bil nikoli izpolnjen, nov element
      //    moramo dodati na konec vektorja (enako kot v prejšnjem
      //    primeru).
      // 3. Podatek je manjši od vseh v vektorju: Zanka se bo ustavila
      //    v prvi ponovitvi in vse bo enako kot sicer.
      // Gornja primera 1 in 2 torej združimo v enega: če se zanka
      // naravno konča, napravimo vv.add(ll).
      //
      // Zgoraj je primer, kako je smiselno vedno pregledati robne
      // pogoje - izrojene situacije. Skoraj vse programerske napake
      // se pojavljajo v takih izjemnih situacijah.
      //
      // Ker potrebujemo indeks elementa za insertElementAt,
      // uporabljamo kar elementAt in ne Iterator.
      int kk = 0;              // indeks elementa, ki ga pregledujemo
      for (kk = 0; kk < vv.size(); kk++) {
        if (ll.compareTo(vv.elementAt(kk)) <= 0) {
          vv.insertElementAt(ll,kk);  break;     // to je pravo mesto
        }
      }
      if (kk >=vv.size()) {            // zanka se je naravno končala
        vv.add(ll);
      }
    }
    dat.close();
    return vv;
  } // beriS

  // testni glavni program
  // podatke preberemo iz datoteke, ki jo navedemo kot prvi argument
  // in jih zapisemo na datoteko, ki jo navedemo kot drugi argument
  public static void main(String[] args) throws IOException {
    Vector podatki = beriS(args[0]);
    Naloga2.pisi(podatki,args[1]);
  } // main

} // class

import java.io.*;
import java.util.*;

public class Naloga6a {

  // Vaja 6
  // Napravimo (statično) metodo, ki kot argument dobi objekt razreda
  // Vector in vrne isti objekt, le da so elementi v njem sortirani po
  // velikosti.
  public static Vector sort(Vector vv) {
    // Tole je primitiven postopek za urejanje (selection sort)
    // ni za resno rabo, ker se izvaja s kvadratno kompleksnostjo
    // tudi med kvadratnimi urejanji je ta postopek slab, ker teče
    // kvadratno tudi na urejenih tabelah (bubble sort - mehurčno
    // urejanje je prav tako enostavno, ampak boljše in celo uporabno
    // za majhne tabele.
    int ss = vv.size();
    // sortiran del tabele bo rastel od začetka; s vsako ponovitvijo
    // spodnje zanke bomo pridelali en element na pravem mestu
    // spremenljivka zeSortiran kaže (na koncu zanke) na zadnji že
    // sortiran element
    for (int zeSortiran = 0; zeSortiran < ss-1; zeSortiran++) {
      // poiščemo najmanjši element nesortiranega dela tabele
      String min = (String)(vv.elementAt(zeSortiran));
      int indMin = zeSortiran;
      for (int ii = indMin+1; ii < ss; ii++) {
        if (min.compareTo(vv.elementAt(ii)) > 0) {
          min = (String)(vv.elementAt(ii)); indMin = ii;
        }
      }
      // zamenjamo prvega nesortiranega in najmanšega
      Object tt = vv.elementAt(zeSortiran);
      vv.setElementAt(vv.elementAt(indMin),zeSortiran);
      vv.setElementAt(tt,indMin);
    }
    return vv;
  } // sort

  // testni glavni program
  // podatke preberemo iz datoteke, ki jo navedemo kot prvi argument
  // in jih zapisemo na datoteko, ki jo navedemo kot drugi argument
  public static void main(String[] args) throws IOException {
    Vector podatki = Naloga1.beri(args[0]);
    sort(podatki);
    Naloga2.pisi(podatki,args[1]);
  } // main

} // class

import java.io.*;
import java.util.*;

public class Naloga6b {

  // Vaja 6
  // Napravimo (statično) metodo, ki kot argument dobi objekt razreda
  // Vector in vrne isti objekt, le da so elementi v njem sortirani po
  // velikosti.
  // DRUGA VERZIJA
  public static Vector bubbleSort(Vector vv) {
    // Tole je primitiven postopek za urejanje (bubble sort - mehurčno
    // urejanje). Uporaben je za majhne tabele. Kompleksnost še vedno
    // raste s kvadratom dolžine tabele.
    int ss = vv.size();
    // Ideja je naslednja (zaradi analogije s prejšnjim postopkom,
    // bomo tudi ta postopek napisali tako, da že sortiran del na
    // začetku, čeprav se ga tradicionalno napiše tako, da sortiran
    // del tabele nastaja na koncu tabele):
    //
    // Prav tako kot prej, imamo tabelo razdeljeno na že sortiran
    // in še nesortiran del.
    // Prav tako bomo poiskali najmanjši element nesortiranega dela
    // in ga dali na začetek, le da bomo to storili malce drugače.
    // Od konca nesortiranega dela tabele bomo šli na začetek in
    // vsakokrat primerjali dva sosednaj elementa. Če sta v napačnem
    // vrstnem redu (večji pred manjšim), ju zamenjamo. Ker se
    // najmanjši element nesortiranega dela vedno zamenja s sosedi,
    // bo zagotovo prišel na vrh. Spotoma pa bomo nekaj reda napravili
    // tudi med ostalimi pari.
    // Ko smo prišli z najmanjšim elementom do vrha nesortiranega
    // dela tabele, vemo, da so vsi elementi nad zadnjo menjavo
    // zagotovo že sortirani, zato si lahko ustrezno označimo konec
    // sortiranega dela rabele.
    int zeSortiran = 0;        // ni nobenega že sortiranega elementa
    while (zeSortiran < ss) {
      int zadnjaMenjava = zeSortiran;
      // poiščemo najmanjši element nesortiranega dela tabele
      for (int ii = ss-2; ii >= zeSortiran ; ii--) {
        if (((String)(vv.elementAt(ii))).compareTo(vv.elementAt(ii+1)) > 0) {
          Object tt = vv.elementAt(ii);
          vv.setElementAt(vv.elementAt(ii+1),ii);
          vv.setElementAt(tt,ii+1);
          zadnjaMenjava = ii;
        }
      }
      zeSortiran = zadnjaMenjava+1;
    }
    return vv;
  } // bubbleSort

  // testni glavni program
  // podatke preberemo iz datoteke, ki jo navedemo kot prvi argument
  // in jih zapisemo na datoteko, ki jo navedemo kot drugi argument
  public static void main(String[] args) throws IOException {
    Vector podatki = Naloga1.beri(args[0]);
    bubbleSort(podatki);
  //  Collections.sort(podatki);
    Naloga2.pisi(podatki,args[1]);
  } // main

} // class

Collections.sort(vektor);

// Osnovni podatki o studentu: ime, priimek, ocena

public class Student implements Comparable {

  // komponente
  String ime;
  String priimek;
  int ocena;

  // konstruira Studenta iz komponent
  public Student(String ii, String pp, int oo) {
    ime = ii;
    priimek = pp;
    ocena = oo;
  } // Student

  // konstruira Studenta iz niza, kjer so s TAB ločeni
  // ime, priimek, ocena (v tem vrstnem redu)
  public Student(String ss) {
    String[] tt = ss.split("\\s"); // če bi hoteli imeti za delimiter
    // le TAB, bi napisali \t; \\s ujame vse vrste presledkov
    ime = tt.length > 0 ? tt[0] : "";
    priimek = tt.length > 1 ? tt[1] : "";
    try { ocena = Integer.parseInt(tt[2]); }
    catch (Exception ee) { ocena = 0; }
  } // Student

  // podatke o Studentu vrnemo kot niz
  public String toString() {
    return ime + " " + priimek + " " + ocena;
  } // toString

  // običajna metoda compareTo,
  // primerja priimek in nato ime (če sta priimka enaka)
  public int compareTo(Object s2) {
    int rv = 0;
    Student ss = (Student)s2;
    if ((rv = this.priimek.compareTo(ss.priimek)) != 0) return rv;
    return this.ime.compareTo(ss.ime);
  } // compareTo

  // običajna metoda equals, primerja priimek in ime
  public boolean equals(Object s2) {
    return this.compareTo((Student)s2) == 0;
  } // equals

} // class

import java.io.*;
import java.util.*;

public class Naloga7 {

  // Vaja 7
  // Napravimo podobno metodo kot v prvi nalogi, le da vemo, da so na
  // datoteki podatki sestavljeni iz imena in priimka študenta ter
  // ocene. Podatki na vhodni datoteki so med seboj ločeni z znaki
  // TAB. Definirajmo razred Student, ki bo vseboval vse tri
  // komponente. V razredu Student definirajmo tudi metodi toString
  // in compareTo (študente med seboj primerja po abecedi). Statična
  // metoda naj vrne vektor objektov razreda Student.

  // Razred Student je definiran na ločeni datoteki

  public static Vector beriStudent(String ime) throws IOException {
    BufferedReader dat = new BufferedReader(new FileReader(ime));
    Vector vv = new Vector();
    while (dat.ready()) {
      {{vv.add(new Student(dat.readLine()));}}
    }
    dat.close();
    return vv;
  } // beriStudent

  // testni glavni program
  // podatke preberemo iz datoteke, ki jo navedemo kot prvi argument
  // izpišemo jih na standardni izhod
  public static void main(String[] args) throws IOException {
    Vector podatki = beriStudent(args[0]);
    System.out.println(podatki);
  } // main

} // class

Alenka	Žeks	5
Aljoša	Balažek	1
Amir	Cesar	8
Anže	Deršek	2
Ana-Marija	Đurić	5
Barbara	Germovšek	4
Branka	Hren	3
Damijana	Javornik	8
Damjana	Jerman	7
Gorazd	Karba	4
Ivana	Kirm	3
Katja	Kožar	2
Maja	Kojzek	5
Maja	Komić	8
Marjana	Leban	5
Matej	Lesar	4
Melinda	Levičar	6
Miran	Medvešček	8
Natalija	Mušič	4
Nina	Pavlin	5
Nina	Podbregar	9
Peter	Sedej	2
Primož	Skok	6
Renata	Skok	1
Romana	Strauss	6
Sebastjan	Tomažič	6
Tadeja	Valner	9

import java.io.*;
import java.util.*;

public class Naloga8 {

  // Vaja 8
  // Enaka nakoga kot naloga 2, le da so v vektorju objekti razreda
  // Student.
  public static void pisiStudent(Vector vv, String ime)
      throws IOException {
    PrintWriter dat = new PrintWriter(new FileWriter(ime));
    Iterator it = vv.iterator();
    while (it.hasNext()) {
	{{Student x = (Student)it.next();}}
      dat.println(x);
    }
    dat.close();
  } // pisi

  // testni glavni program
  // podatke preberemo iz datoteke, ki jo navedemo kot prvi argument
  // in jih zapisemo na datoteko, ki jo navedemo kot drugi argument
  public static void main(String[] args) throws IOException {
    {{Vector podatki = Naloga7.beriStudent(args[0]);}}
    {{pisiStudent(podatki,args[1]);}}
  } // main

} // class

// Dodatni podatki o studentu: ime, priimek, ocena

public class StudentR1 extends Student {

  // komponente
  int ocena2;

  // konstruira StudentaR1 iz komponent
  public StudentR1(String ii, String pp, int oo, int o2) {
    super(ii,pp,oo);
    ocena2 = o2;
  } // StudentR1

  // konstruira StudentaR1 iz niza, kjer so s TAB ločeni
  // ime, priimek, ocena (v tem vrstnem redu)
  public StudentR1(String ss) {
    super(ss);
    ocena2 = 0;
  } // StudentR1

  // podatke o StudentuR1 vrnemo kot niz
  public String toString() {
    return ime + " " + priimek + " " + ocena + " " + ocena2;
  } // toString

  // Spodnji dve metodi uporabljamo zato, ker vedno beremo le
  // komponento ocena. Prvo verzijo uporabimo, ko smo našli študenta,
  // ki je že v tabeli. Drugo verzijo uporabimo, ko imamo študenta,
  // ki ga še ni v tabeli.

  // oceno prepiše iz student.ocena v this.ocena2
  public void nastavi2(StudentR1 student) {
    this.ocena2 = student.ocena;
  } // nastavi2

  // oceno prepiše iz this.ocena v this.ocena2
  public void nastavi2() {
    this.ocena2 = this.ocena;
    this.ocena = 0;
  } // nastavi2

} // class

import java.io.*;
import java.util.*;

public class Naloga10 {

  // Vaja 10
  // Na osnovi razreda Student napravimo razred StudentR1, ki bo
  // vseboval vse komponente Studenta, poleg tega pa še oceno na
  // drugem kolokviju. Napišimo statično metodo, ki bo dobila imeni
  // dveh datotek (prve z rezultati prvega kolokvija in druge z
  // rezultati drugega kolokvija).
  // Metoda bo prebrala obe datoteki in vrnila vektor objektov
  // razreda StudentR1. V vektorju se lahko vsak student pojavi le
  // enkrat. Upoštevajmo, da se lahko posamezni študent pojavi le v
  // eni datoteki, tedaj naj ima oceno iz drugega kolokvija enako 0.
  public static Vector beriDve(String ime1, String ime2)
      throws IOException {
    // prvo datoteko beremo po starem (kot v nalogi 7)
    // metode Naloga7.beriStudent() ne moremo direktno uporabljati,
    // ker dela objekte razreda Student in ne StudentR1
    BufferedReader dat = new BufferedReader(new FileReader(ime1));
    Vector vv = new Vector();
    while (dat.ready()) {
      vv.add(new StudentR1(dat.readLine())); /*M*/
    }
    dat.close();
    // preberemo še drugo datoteko
    dat = new BufferedReader(new FileReader(ime2));
    while (dat.ready()) {
      // študenta preberemo kar v nov objekt (zato, da konstruktor
      // opravi vse delo)
      StudentR1 ss = new StudentR1(dat.readLine()); /*M*/
      int ind = vv.indexOf(ss);// indeks ss v vektorju (-1, če ga ni)
      if (ind < 0) {                                   // nov študent
        ss.nastavi2();  vv.add(ss);
      }
      else {                                      // obstoječ študent
        ((StudentR1)vv.elementAt(ind)).nastavi2(ss);
      }
    }
    dat.close();
    return vv;
  } // beriDve

  // testni glavni program
  // podatke preberemo iz datotek, ki jo navedemo kot prvi in drugi argument
  // izpi1emo jih na standardni izhod
  public static void main(String[] args) throws IOException {
    Vector podatki = beriDve(args[0], args[1]);
    System.out.println(podatki);
  } // main

} // class