Jak to naprogramovat v javě

Dobrý den.

Neví si někdo rady s tím, jak to naprogramovat v javě? Kde mám chybu. Já to dělal ve scite. Hlásí mi to chybu 378. class, interface, or enum expected

Zadání:
Název: Jednoduchý generátor pseudonáhodných čísel, řazení a vizualizace posloupnosti náhodně generovaných prvků.
Vytvořte program, který bude generovat pseudonáhodná čísla podle následujícího algoritmu:
1) Program umocní zadané dvouciferné číslo (startovací hodnotu) na druhou.
2) Z výsledku použije první dvě cifry (zleva), čímž získá dvouciferné číslo.
3) K tomuto číslu přičte jedničku a výsledkem je nově vygenerované pseudonáhodné číslo.
4) Body 1) až 3) se opakují tak dlouho, dokud se nezačnou pseudonáhodná čísla opakovat (tj. končí výskytem pseudonáhodného čísla, které již bylo dříve vygenerováno).
Příklad vygenerování pseudonáhodných čísel:
67 * 67 = 4489 -> 44 + 1 = 45
45 * 45 = 2025 -> 20 + 1 = 21
21 * 21 = 441 -> 44 + 1 = 45 - tato hodnota se již v posloupnosti vyskytla, generování končí
Posloupnost pseudonáhodných čísel začínající startovací hodnotou 67 je tedy 67, 45, 21
Řazení prvků vygenerované posloupnosti
Pro seřazení prvků takto vygenerované posloupnosti použijte jednu z metod řazení SelectSort (řazení výběrem), InsertSort (řazení vkládáním) nebo BubbleSort (řazení záměnou). Konkrétní metodu, kterou máte aplikovat, zjistíte na webové stránce v zadání cvičení, v němž je zadání SP vysvětlováno.
Vizualizace výsledků
Vytvořenou i vzestupně seřazenou posloupnost zobrazte použitím nástroje DrawingTool. Vzhled vizualizace, její rozměr, použité barvy, tloušťky čar (tj. sloupců) a rozložení obou posloupností je ponecháno na kreativitě programátora s těmito omezeními:
1) Najednou musí být vidět celá původní i celá seřazená posloupnost.
2) Grafy obou posloupností budou obsahovat vodorovné úsečky, představující dělení osy Y na deset dílů. Díky tomu bude možno snadno ověřit správnost vizualizace.
Je možné se inspirovat vzhledem vizualizace dat vzorového příkladu: pseudo10.jpg
Ovládání programu
Program bude možné ovládat klávesnicí přímo z příkazové řádky s volbou spuštění programu bez nebo se zadáním parametru.
Ovládání bez zadání parametru
Nebude-li na příkazové řádce žádný parametr, program si vyžádá zadání startovací hodnoty. Předpokládá se disciplinovaný uživatel, takže zadanou hodnotu není třeba kontrolovat. Ze startovací hodnoty vytvořte uvedeným způsobem pseudonáhodnou posloupnost. Tuto posloupnost vypište na obrazovku, proveďte její vizualizaci, pak posloupnost seřaďte vzestupně a výsledek opět vypište na obrazovku a následně proveďte vizualizaci. Formát výpisu na obrazovku je závazný:
počet_prvků_posloupnosti [první_prvek, druhý_prvek, ..., poslední_prvek]
Například pro startovací hodnotu 67 bude výpis:
3 [67, 45, 21]
3 [21, 45, 67]
- 2 -
Ovládání se zadáním parametru
Bude-li na příkazové řádce parametr, bude představovat jméno vstupního souboru. Opět předpokládáme disciplinovaného uživatele, takže jméno souboru bude zadáno správně, tento soubor existuje a není třeba toto kontrolovat.
Vstupní soubor bude textový a na každé řádce bude mít jedno dvouciferné číslo, které se bude považovat za startovací hodnotu. Počet řádek v souboru není omezen, jednotlivé startovací hodnoty se mohou opakovat, musí být však zadány správně (tj. dvouciferná čísla – není třeba kontrolovat).
Ukázka obsahu vstupního souboru:
10
11
83
Pro každou startovací hodnotu vytvořte již dříve uvedeným způsobem pseudonáhodnou posloupnost a zapište do jedné řádky výstupního textového souboru s názvem vystup.txt. Na další řádku tohoto souboru zapište tutéž posloupnost, ovšem seřazenou a oddělenou od dalšího výpisu prázdnou řádkou. Formát výpisu bude zcela totožný s již dříve uvedeným výpisem při spuštění programu bez parametru.
Ukázka obsahu výstupního souboru:
20 [10, 11, 13, 17, 29, 85, 73, 54, 30, 91, 83, 69, 48, 24, 58, 34, 12, 15, 23, 53]
20 [10, 11, 12, 13, 15, 17, 23, 24, 29, 30, 34, 48, 53, 54, 58, 69, 73, 83, 85, 91]
19 [11, 13, 17, 29, 85, 73, 54, 30, 91, 83, 69, 48, 24, 58, 34, 12, 15, 23, 53]
19 [11, 12, 13, 15, 17, 23, 24, 29, 30, 34, 48, 53, 54, 58, 69, 73, 83, 85, 91]
16 [83, 69, 48, 24, 58, 34, 12, 15, 23, 53, 29, 85, 73, 54, 30, 91]
16 [12, 15, 23, 24, 29, 30, 34, 48, 53, 54, 58, 69, 73, 83, 85, 91]
Po zpracování všech řádek ze vstupního souboru program ihned skončí. Nevypisuje tedy nic na obrazovku a nečeká na žádné vstupy od uživatele.
Všechny výjimky řešte pouze pomocí e.printStackTrace().

Jak jsem se to snažil řešit.

import java.awt.Color;
import java.io.File;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Scanner;
//import ppa1.DrawingTool;
/**
* Program na generovani pseudonahodnych cisel podle startovniho cisla.
* Nasledne tuto posloupnost setridi pomoci algoritmu BubbleSort
* a pomoci nastroje DrawingTool vykresli na obrazovku graf puvodni
* i serazene posloupnosti.
*
* @author
*/
public class Ppa1_SP_A11B0126K {
// Nastaveni konstant (nemennych cisel) pro vykresleni okna DrawingToolu
/** Velikost okna nastroje DrawingTool na vysku */
private static final int VYSKA_OKNA = 700;
/** Velikost okna nastroje DrawingTool na sirku */
private static final int SIRKA_OKNA = 700;
/** Pocet horizontalnich linek */
private static final int POCET_RADEK = 50;
/*
* Aplikace zacina metodou main.
* Vstupni parametr nazvany "args" datoveho typu pole retezcu (String [])
* obsahuje zadane retezce pri spousteni aplikace z prikazove radky.
* Kdyz tedy do prikazove radky napises spusteni teto aplikace takto:
*
* java Ppa1_SP_A11B0126K vstup.txt
*
* tak pak v teto promenne pod indexem 0 najdes retezec "vstup.txt":
* String nazevSouboru = args[0];
*
* Kdybys tam zadal jeste dalsi retezce, budou na odpovidajicich indexech
* nasledovat... to se nas ale netyka.
*
* Kdyz tedy nazev souboru nezadame, aplikace si od nas vyzada jedno
* dvouciferne celocislo, ktere zadame klavesnici. Provede se vypocet
* cele posloupnosti algoritmem popsanym v zadani a pomoci nastroje
* "DrawingTool" (dale jen DT) se vykresli neserazena (modre) i serazena
* (cervene) posloupnost na obrazovku.
* Trida DT je naprogramovany kus kodu, ktery muzeme vyuzit ke zjednoduseni
* procesu vykresleni neceho na obrazovku. Poskytuje nam pouze zakladni
* metodu "line", tedy vykresleni jedne cary. Graf tedy musime vykreslit
* pomoci nekolika cyklu, ktere z jednotlivych car (poskladanych tesne
* na sebe) vytvori podobu grafu.
*/
/**
* Hlavni metoda semestralni prace.
* Cte data z klavesnice nebo ze vstupniho
* souboru,nachazi-li se v zadanych argumentech
* z prikazove radky.
*
* @param args Argumenty prikazove radky
*/
public static void main(String[] args) {
// Kdyz je zadan nazev vstupniho souboru argumentem z prikazove radky
if (args.length> 0) {
/*
* V bloku "try" se odehrava nejaky "nebezpecny" kod, ktery by nam
* mohl aplikaci shodit. Pokud by se tak stalo, aplikace diky bloku
* "try" nespadne, ale kod skoci do bloku "catch", kde vyjimku muzeme
* osetrit. V zadani ale je, ze nemame na vyjimky reagovat.
*/
try {
// Vytvoreni odkazu na soubor s nazvem prevzatym z pole argumentu,
// viz. vyse - tj. hodnota promenne args[0] bude "vstup.txt".
File vstup = new File(args[0]);
// Vytvoreni objektu Scanner (do promenne "sc") - pomuze nam cist
// ze vstupniho souboru - ten predavame jako parametr metody (vstup)
Scanner sc = new Scanner(vstup);
// Trida PrintStream nam umozni jednoduse zapostovat do souboru,
// ktery jsme si nazvali "vystup.txt" - vytvori se pri spusteni apl.
PrintStream p = new PrintStream("vystup.txt");
/*
* "while" cyklus (s podminkou na zacatku) - pobezi tolikrat, kolik
* bude mit vstupni soubor vstupnich cisel.
* Doslova se zde ptame "dokud mas nejake dalsi celocislo, tak delej"
*/
while (sc.hasNextInt()) {
// Kdyz tedy vime, ze nejake dalsi cislo tam je, nacteme ho
int data = sc.nextInt();
/*
* Do nove vytvorene promenne "a" datoveho typu pole celocisel
* ulozime vysledek metody "generujPosloupnost" kam posilame
* nactene celocislo "data" - vrati se nam neserazena posloupnost
*/
int[] a = generujPosloupnost(data);
/*
* Do nove vytvorene promenne "b" datoveho typu pole celocisel
* ulozime vysledek metody "bubbleSort" kam posilame nasi
* neserazenou posloupnost ("a") - vysledkem bude v promenne
* "b" pole serazene posloupnosti
*/
int[] b = bubbleSort(a);
// Pomoci promenne "p" (objekt tridy PrintStream) zapiseme
// vysledky do souboru - neserazenou i serazenou posloupnost
p.println(a.length + Arrays.toString(a));
p.println(b.length + Arrays.toString(b));
p.println(); // Odradkovani
/*
* Nyni konci aktualni prubeh cyklu a vracime se zpet k prikazu
* while do podminky, tedy se ptame, jestli ma jeste Scanner
* nejake dalsi cislo ke cteni. Pokud ano, zacina cyklus znovu.
* Pokud ne, vyskakujeme pres nasledujici uzavrenou zavorku
* ven z tela cyklu na prikaz p.close();
*/
}
// Uzavreni souboru "vystup.txt" - kvuli uvolneni prostredku
// operacniho systemu (nebude tento soubor jiz drzet otevreny).
p.close();
} catch (Exception e) {
// Zakladni reakce na vyjimku - vypis pametoveho zasobniku Javy
e.printStackTrace();
}
}
// Pokud neni zadany vstupni soubor, aplikace precte cislo z klavesnice
else {
// Vytvoreni Scanneru, ktery bude cist z klavesnice - to mu rekneme
// parametrem "System.in" oznacujici prave standardni vstup (klavesnici)
Scanner sc = new Scanner(System.in);
// Vypis textu do konzole
System.out.print("Zadej startovne cislo: ");
// Nasteni celocisla od uzivatele (z klavesnice)
// Zde program stoji, dokud uzivatel nezada cislo a potvrdi Enterem
int data = sc.nextInt();
// Opet vygenerovani a nasledne serazeni posloupnosti stejne, jako vyse
int[] a = generujPosloupnost(data);
int[] b = bubbleSort(a);
// Vypis vysledku na standardni vystup (System.out) tj. obrazovku
System.out.println(a.length + Arrays.toString(a));
System.out.println(b.length + Arrays.toString(b));
// Zavolani metody vykresli, kam predame pomoci parametru
// serazenou i neserazenou posloupnost
vykresli(a, b);
}
}
/**
* Metoda na generovani pseudonahodne posloupnosti podle startovni hodnoty
* Vyuziva generateNum(int numbers)
*
* @param puvodniCislo Puvodni cislo pro vypocet posloupnosti
* @return posloupnost Pole cisel posloupnosti
*/
public static int[] generujPosloupnost(int puvodniCislo) {
//Vygenerovani cele posloupnosti algoritmem popsanym v zadani...
// Bude nam slouzit pozdeji pro ukonceni cyklu po
// nalezeni cele posloupnosti
boolean c = true;
/*
* Vytvoreni pole celocisel pro ukladani posloupnosti
* Volime velikost 200, coz je dostacujici (vysledek nikdy v nasem pripade
* nebude vetsi). Jedna se ale mimochodem o neefektivni zpusob...
*/
int[] posloupnost = new int[200];
// Jako prvni prvek posloupnosti dosadime puvodni cislo
posloupnost[0] = puvodniCislo;
// Nastavime pomocnou promennou "x" na 1
// Bude nam ukazovat na aktualni index vytvareneho cisla posloupnosti v poli
int x = 1;
// Dokud bude platit, ze je "c" true, bude cyklus probihat
while (c) {
/*
* Do aktualniho indexu vygenerujeme dalsi cislo posloupnosti pomoci
* metody generujCislo, kam posleme hodnotu predchazejiciho cisla - tj.
* toho o 1 index v poli nize (posloupnost[x - 1])
*/
posloupnost[x] = generujCislo(posloupnost[x - 1]);
// Navysime hodnotu x o 1, aby priste ukazoval na dalsi index
x++;
/*
* Prohledame posloupnost, jestli se uz nahodou nove vygenerovane cislo
* v posloupnosti nenachazi. Pokud ano (je tedy cislo jiz v posloupnosti
* zapsane dvakrat - nekde v posloupnosti a na poslednim indexu, kam se
* zapisovalo = (x - 1) v tuto chvili jiz.
*/
for (int y = 0; y 0; x-) {
boolean serazeno = true;
for (int y = 1; y serazna[y]) {
int tmp = serazna[y - 1];
serazna[y - 1] = serazna[y];
serazna[y] = tmp;
serazeno = false;
}
}
// Pokud jsme jiz vse seradili, ukoncime cyklus
if (serazeno) {
break;
}
}
// Vratime pole serazene posloupnosti
return serazna;
}
/**
* Metoda na vykresleni grafu pomoci nastroje DrawingTool
*
* @param a Neusporadane pole cisel
* @param b Usporadane pole cisel
*/
public static void vykresli(int[] a, int[] b) {
/*
* Vytvoreni objektu DrawingToolu, kam predame parametry pro vytvoreni okna, tedy:
* sirku a vysku okna, barvu pozadi a "true" zapne antialising (vyhlazovani hran)
*/
DrawingTool dt = new DrawingTool(SIRKA_OKNA, VYSKA_OKNA, Color.WHITE, true);
// Nastavime barvu "stetce" (cary) na sedou
// Tj. od ted co nakreslime tak bude kresleno sedou barvou
dt.setColor(Color.BLACK);
// Vypocitani mezery mezi horizontalnima linkama
int mezeraMeziRadky = VYSKA_OKNA / POCET_RADEK;
// Vykresleni horizontalnich linek
for (int y = 0; y