import java.io.*;
import java.util.Scanner;
// A Serializable interfész implementálása az objektumként való mentéshez kell
class Matrix implements Serializable {
// A mátrix sorainak és oszlopainak a száma
int s, o;
// A mátrix (mint kétdimenziós tömb)
int[][] a;
public Matrix(int[][] a) {
this.a = a;
s = a.length;
// Ilyen eset ugyan nem lesz, de biztos ami biztos
o = (s > 0) ? a[0].length : 0;
}
public Matrix() {
String hiba = "Nem megfelelő input!";
Scanner sc = new Scanner(System.in);
boolean ok;
do {
ok = true;
try {
System.out.print("Sorok száma:");
s = Integer.parseInt(sc.next());
if (s <= 0) {
throw new Exception(hiba);
}
System.out.print("Oszlopok száma:");
o = Integer.parseInt(sc.next());
if (o <= 0) {
throw new Exception(hiba);
}
a = new int[s][o];
for (int i = 0; i < s; i++) {
for (int j = 0; j < o; j++) {
System.out.print((i+1) + ". sor " + (j+1) + ". elem:");
a[i][j] = Integer.parseInt(sc.next());
}
}
}
catch (Exception e) {
System.out.println(hiba);
ok = false;
}
} while (!ok);
}
public Matrix(int s, int o, int tol, int ig) {
this.s = s;
this.o = o;
this.a = new int[s][o];
for (int i = 0; i < s; i++) {
for (int j = 0; j < o; j++) {
a[i][j] = (int)Math.floor(Math.random() * (ig - tol + 1) + tol);
}
}
}
public String toString() {
if (s == 0) {
// Ilyen eset ugyan nem lesz, de biztos ami biztos
return "[[]]";
} else {
StringBuffer st = new StringBuffer("[");
for (int i = 0; i < s; i++) {
st.append("[");
for (int j = 0; j < o; j++) {
st.append(a[i][j] + ",");
}
st.replace(st.length() - 1, st.length(), "],");
}
st.replace(st.length() - 1, st.length(), "]");
return new String(st);
}
}
public boolean szimm() {
boolean r = s == o;
for (int i = 0; i < s - 1 && r; i++) {
for (int j = i + 1; j < o && r; j++) {
if (a[i][j] != a[j][i]) {
r = false;
}
}
}
return r;
}
// A mátrix mentése bináris fájlba objektumként
public void ment(String fnev) {
try {
ObjectOutputStream os = new ObjectOutputStream(
new FileOutputStream(fnev));
os.writeObject(this);
os.close();
}
catch (Exception e) {
System.out.println(e);
}
}
// A mátrix betöltése bináris fájlból objektumként
public static Matrix betolt(String fnev) {
try {
ObjectInputStream os = new ObjectInputStream(
new FileInputStream(fnev));
Object obj = os.readObject();
os.close();
return (Matrix)obj;
}
catch (Exception e) {
System.out.println(e);
return null;
}
}
}
public class v_01 {
public static void main(String[] args) {
// Egy szimmetrikus mátrix
int[][] a = {{1, 2, 3}, {2, 5, 7}, {3, 7, 8}};
Matrix mtx = new Matrix(a);
System.out.println("Egy szimmetrikus mátrix:");
System.out.println(mtx);
System.out.println(mtx.szimm());
// Egy billentyűzetről bekért mátrix
mtx = new Matrix();
System.out.println("A bekért mátrix:");
System.out.println(mtx);
System.out.println(mtx.szimm());
// Egy generált mátrix
System.out.println("Egy generált mátrix:");
mtx = new Matrix(2, 2, 1, 2);
System.out.println(mtx);
System.out.println(mtx.szimm());
// Mátrix mentése fájlba
mtx.ment("adat.dat");
// Mátrix betöltése fájlból
mtx = Matrix.betolt("adat.dat");
System.out.println("A fájlból betöltött mátrix:");
System.out.println(mtx);
if (mtx != null) {
System.out.println(mtx.szimm());
}
}
}

import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.*;
abstract class SikIdom implements Comparable {
public abstract double terulet();
public int compareTo(Object obj) {
double ter1 = terulet();
double ter2 = ((SikIdom) obj).terulet();
if (ter1 < ter2)
return -1;
if (ter1 > ter2)
return 1;
return 0;
/* Másik megoldás:
return (int)Math.round((terulet()-((SikIdom)obj).terulet()));
*/
}
}
class Kor extends SikIdom {
protected double r;
public Kor(double r) {
this.r = r;
}
public double terulet() {
return Math.pow(r, 2) * Math.PI;
}
public String toString() {
return "Kör: r = " + r + ", terulet = " + terulet();
}
}
class Teglalap extends SikIdom {
protected double a,b;
public Teglalap(double a, double b) {
this.a = a;
this.b = b;
}
public double terulet() {
return a*b;
}
public String toString() {
return "Téglalap: a = " + a + ", b = " + b +
", terület = " + terulet();
}
}
class Negyzet extends Teglalap {
public Negyzet(double a) {
super(a,a);
}
public String toString() {
return "Négyzet: a = " + a +
", terület = " + terulet();
}
}
class SikIdomok {
private Vector idomok = new Vector();
public SikIdomok() {
idomok.add(new Teglalap(6, 9));
idomok.add(new Kor(4));
idomok.add(new Negyzet(5));
idomok.add(new Negyzet(7));
idomok.add(new Kor(1));
}
void lista(String info) {
System.out.println("\n" + info);
for (int i = 0; i < idomok.size(); i++)
System.out.println(idomok.get(i));
}
public void lista_txt(String fnev) {
// Új Vector-t, hogy az eredeti sorrend is megmaradjon
Vector rend = new Vector(idomok);
Collections.sort(rend);
try {
PrintStream ps = new PrintStream(
new FileOutputStream(fnev));
ps.println("Síkidomok száma: " + idomok.size());
for (int i = 0; i < rend.size(); i++)
ps.println(rend.get(i));
ps.close();
}
catch (Exception e) {
System.out.println(e);
}
}
double atlagTerulet() {
if (idomok.isEmpty())
return 0;
double osszTer = 0;
for (int i = 0; i < idomok.size(); i++) {
SikIdom sikIdom = (SikIdom) idomok.get(i);
osszTer += sikIdom.terulet();
}
return osszTer / idomok.size();
}
int korokSzama() {
int ksz = 0;
for (int i = 0; i < idomok.size(); i++)
if (idomok.get(i) instanceof Kor)
ksz++;
return ksz;
}
void run() {
if (idomok.isEmpty()) {
System.out.println("\nNincs egyetlen sikidom sem!");
return;
}
// Lista a sikidomok létrehozásának sorrendjében
lista("Sikidomok:");
// Átlagterület
System.out.println("\nSikidomok átlag területe: " + atlagTerulet());
// Körök száma
System.out.println("\nKörök száma: " + korokSzama());
// Legkisebb és legnagyobb területű síkidom
System.out.println("\nLegkisebb területű sikidom : " + Collections.min(idomok));
System.out.println("Legnagyobb területű sikidom: " + Collections.max(idomok));
// Terület szerint rendezett lista szövegfájlba
Collections.sort(idomok);
lista_txt("adatok.txt");
}
}
public class v_02 {
public static void main(String[] args) {
new SikIdomok().run();
}
}

import java.util.Scanner;
import java.util.TreeSet;
import java.util.Vector;
interface ILotto {
int Db = 5;
int Tol = 1;
int Ig = 90;
}
class Szelveny implements ILotto {
// A szelvény számai
TreeSet<Integer> sz = new TreeSet<>();
Szelveny(boolean general) {
int a, i;
if (general) {
i = 0;
while (i < ILotto.Db) {
a = (int)Math.floor(Math.random() * (Ig - Tol + 1) + Tol);
if (!sz.contains(a)) {
sz.add(a);
i++;
}
}
} else {
String hiba = "Nem megfelelő input!";
Scanner sc = new Scanner(System.in);
boolean ok;
do {
ok = true;
sz.clear();
try {
for (i = 0; i < Db; i++) {
System.out.print((i + 1) + ". szám:");
a = Integer.parseInt(sc.next());
if (a < Tol || a > Ig) {
throw new RuntimeException(hiba);
} else if (sz.contains(a)) {
throw new RuntimeException(hiba);
} else {
sz.add(a);
}
}
}
catch (Exception e) {
System.out.println(hiba);
ok = false;
}
} while (!ok);
}
}
public String toString() {
return sz.toString();
}
}
class Szelvenyek {
//Generált szelvények
Vector<Szelveny> szelv = new Vector<>();
//Nyerőszelvény
Szelveny nysz;
Szelvenyek () {
szelv.add(new Szelveny(true));
szelv.add(new Szelveny(true));
szelv.add(new Szelveny(true));
for (int i = 0; i < szelv.size(); i++) {
System.out.println((i + 1) + ". szelvény:" + szelv.get(i));
}
nysz = new Szelveny(false);
listaz();
}
int talalat(Szelveny sz1, Szelveny sz2) {
TreeSet<Integer> metszet = new TreeSet<>();
metszet.addAll(sz1.sz);
metszet.retainAll(sz2.sz);
return metszet.size();
}
void listaz() {
int i, t;
System.out.println("Nyerőszelvény:" + nysz);
System.out.println("Szelvények és találatuk:");
for (i = 0; i < szelv.size(); i++) {
t = talalat(szelv.get(i), nysz);
System.out.println((i + 1) + ". szelvény:" + szelv.get(i).toString() + ", találat:" + t);
}
}
}
public class v_03 {
public static void main(String[] args) {
new Szelvenyek();
}
}

import java.io.*;
import java.util.ArrayList;
import java.util.List;
// --- 1. EGYEDI KIVÉTEL OSZTÁLY ---
class InvalidDataException extends Exception {
public InvalidDataException(String message) {
super(message);
}
}
// --- 2. SIM KÁRTYA OSZTÁLY ---
class SIMKartya {
private String telefonszam;
private String pin;
public SIMKartya(String telefonszam, String pin) throws InvalidDataException {
setTelefonszam(telefonszam);
setPin(pin);
}
public String getTelefonszam() {
return telefonszam;
}
public String getPin() {
return pin;
}
public void setTelefonszam(String telefonszam) throws InvalidDataException {
if (telefonszam == null || telefonszam.length() != 9 || !telefonszam.matches("\\d+")) {
throw new InvalidDataException("Hiba: A telefonszámnak pontosan 9 számjegyből kell állnia!");
}
String eleje = telefonszam.substring(0, 2);
if (!eleje.equals("20") && !eleje.equals("30") && !eleje.equals("50") && !eleje.equals("70")) {
throw new InvalidDataException("Hiba: A telefonszám csak 20, 30, 50 vagy 70 körzetszámmal kezdődhet!");
}
this.telefonszam = telefonszam;
}
public void setPin(String pin) throws InvalidDataException {
if (pin == null || pin.length() < 4 || pin.length() > 8 || !pin.matches("\\d+")) {
throw new InvalidDataException("Hiba: A PIN kódnak 4 és 8 közötti számjegyből kell állnia!");
}
this.pin = pin;
}
@Override
public String toString() {
String formazottSzam = telefonszam.substring(0, 2) + "-" +
telefonszam.substring(2, 5) + "-" +
telefonszam.substring(5);
return formazottSzam + " " + pin;
}
}
// --- 3. SZOLGÁLTATÓ OSZTÁLY ---
class Szolgaltato {
private List<SIMKartya> kartyak;
public Szolgaltato() {
this.kartyak = new ArrayList<>();
}
public void ujSIMKartya(SIMKartya ujKartya) {
for (SIMKartya kártya : kartyak) {
if (kártya.getTelefonszam().equals(ujKartya.getTelefonszam())) {
try {
kártya.setPin(ujKartya.getPin());
return;
} catch (InvalidDataException e) {
System.out.println("Sikertelen PIN felülírás: " + e.getMessage());
return;
}
}
}
kartyak.add(ujKartya);
}
@Override
public String toString() {
List<SIMKartya> rendezettKartyak = new ArrayList<>(kartyak);
rendezettKartyak.sort((k1, k2) -> k1.getTelefonszam().compareTo(k2.getTelefonszam()));
StringBuilder sb = new StringBuilder();
for (SIMKartya kártya : rendezettKartyak) {
sb.append(kártya.toString()).append(System.lineSeparator());
}
return sb.toString();
}
public void mentFajlba(String fajlNev) throws IOException {
try (PrintWriter pw = new PrintWriter(new FileWriter(fajlNev))) {
pw.print(this.toString());
}
}
public static Szolgaltato betoltFajlbol(String fajlNev) {
Szolgaltato ujSzolgaltato = new Szolgaltato();
try (BufferedReader br = new BufferedReader(new FileReader(fajlNev))) {
String sor;
while ((sor = br.readLine()) != null) {
if (sor.trim().isEmpty()) continue;
String[] reszek = sor.split(" ");
if (reszek.length == 2) {
String tisztaSzam = reszek[0].replace("-", "");
String pin = reszek[1];
SIMKartya kártya = new SIMKartya(tisztaSzam, pin);
ujSzolgaltato.ujSIMKartya(kártya);
}
}
return ujSzolgaltato;
} catch (Exception e) {
System.out.println("Hiba történt a beolvasás során: " + e.getMessage());
return null;
}
}
}
// --- 4. FUTTATHATÓ TESZT OSZTÁLY ---
public class vizsga {
public static void main(String[] args) {
System.out.println("--- SIM Kártya Nyilvántartó Teszt ---\n");
Szolgaltato szolgaltato = new Szolgaltato();
// 1. Kivételkezelés tesztelése (Hibás adatok)
System.out.println("-> Hibás adatok tesztelése:");
try {
SIMKartya hibas1 = new SIMKartya("401234567", "1234"); // Rossz körzet
} catch (InvalidDataException e) {
System.out.println("Elkapott kivétel (Körzetszám hiba): " + e.getMessage());
}
try {
SIMKartya hibas2 = new SIMKartya("201234567", "123"); // Túl rövid PIN
} catch (InvalidDataException e) {
System.out.println("Elkapott kivétel (PIN hossz hiba): " + e.getMessage());
}
// 2. Helyes adatok hozzáadása
System.out.println("\n-> Sikeres kártya hozzáadások:");
try {
szolgaltato.ujSIMKartya(new SIMKartya("309876543", "4444"));
szolgaltato.ujSIMKartya(new SIMKartya("201234567", "1111"));
szolgaltato.ujSIMKartya(new SIMKartya("705556666", "99999"));
System.out.println("Sikeresen hozzáadva 3 db kártya.");
} catch (InvalidDataException e) {
System.out.println("Nem várt hiba: " + e.getMessage());
}
// 3. Listázás (Automatikusan sorba rendezve a telefonszámok szerint)
System.out.println("\n-> Szolgáltató aktuális állapota (Rendezve):");
System.out.print(szolgaltato);
// 4. PIN felülírás tesztelése
System.out.println("-> PIN kód felülírás tesztelése a 201234567 számon (új PIN: 8888):");
try {
szolgaltato.ujSIMKartya(new SIMKartya("201234567", "8888"));
} catch (InvalidDataException e) {
System.out.println(e.getMessage());
}
System.out.print(szolgaltato);
// 5. Fájlba mentés
String fajlNev = "sim_adatok.txt";
System.out.println("-> Adatok mentése a '" + fajlNev + "' fájlba...");
try {
szolgaltato.mentFajlba(fajlNev);
System.out.println("Mentés sikeres.");
} catch (IOException e) {
System.out.println("Hiba a mentés során: " + e.getMessage());
}
// 6. Fájlból betöltés egy teljesen új Szolgáltató objektumba
System.out.println("\n-> Új szolgáltató objektum létrehozása és adatok betöltése a fájlból:");
Szolgaltato ujSzolgaltato = Szolgaltato.betoltFajlbol(fajlNev);
if (ujSzolgaltato != null) {
System.out.println("A beolvasott új szolgáltató adatai:");
System.out.print(ujSzolgaltato);
} else {
System.out.println("A betöltés sikertelen volt, null referenciát kaptunk.");
}
}
}

import java.util.Random;
public class Titkosito {
// Konstansként deklaráljuk a mátrixok méretét
public static final int N = 4;
/**
* 1. FELADATPONT (2p)
* Véletlenszerű, angol nagybetűkből álló nxn-es mátrix generálása.
*/
public static char[][] generalBetumatrix() {
Random rand = new Random();
char[][] matrix = new char[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Az angol ábécé nagybetűi 'A'-tól 'Z'-ig (65-90 ASCII kódok)
matrix[i][j] = (char) ('A' + rand.nextInt(26));
}
}
return matrix;
}
/**
* 2. FELADATPONT (3p)
* Véletlenszerű sablon (bináris mátrix) generálása,
* amely pontosan a megadott mennyiségű 1-est tartalmazza.
*/
public static int[][] generalSablon(int dbOnes) {
int[][] sablon = new int[N][N];
Random rand = new Random();
int elhelyezett = 0;
// Addig sorsolunk pozíciókat, amíg el nem érjük a kívánt darabszámot
while (elhelyezett < dbOnes) {
int r = rand.nextInt(N);
int c = rand.nextInt(N);
if (sablon[r][c] == 0) {
sablon[r][c] = 1;
elhelyezett++;
}
}
return sablon;
}
/**
* 3. FELADATPONT (3p)
* Egy adott betűmátrix sztringgé alakítása sorfolytonosan, mátrix alakban.
*/
public static String matrixToString(char[][] matrix) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
sb.append(matrix[i][j]).append(" ");
}
sb.append("\n"); // Új sor a mátrix formátumhoz
}
return sb.toString();
}
/**
* 3. FELADATPONT - Második rész (3p)
* Egy adott sablon sztringgé alakítása sorfolytonosan, mátrix alakban.
*/
public static String sablonToString(int[][] sablon) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
sb.append(sablon[i][j]).append(" ");
}
sb.append("\n");
}
return sb.toString();
}
/**
* 4. FELADATPONT (2p)
* Meghatározza a sablon használatával (ahol 1-es van) leolvasható szót sorfolytonosan.
*/
public static String alkalmazSablon(char[][] betumatrix, int[][] sablon) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (sablon[i][j] == 1) {
sb.append(betumatrix[i][j]);
}
}
}
return sb.toString();
}
/**
* 5. FELADATPONT (3p)
* Elforgat jobbra 90 fokkal egy adott sablont, majd visszaadja az új mátrixot.
*/
public static int[][] elforgatSablon(int[][] sablon) {
int[][] forgatott = new int[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Jobbra forgatás képlete: az (i, j) pozíció a (j, N - 1 - i) helyre kerül
forgatott[j][N - 1 - i] = sablon[i][j];
}
}
return forgatott;
}
/**
* 6. FELADATPONT (3p)
* Visszafejti a szöveget az eredeti, majd a 90, 180 és 270 fokkal elforgatott sablonokkal.
*/
public static String visszafejt(char[][] betumatrix, int[][] sablon) {
StringBuilder teljesSzo = new StringBuilder();
int[][] aktualisSablon = sablon;
// 4 fázis: 0°, 90°, 180°, 270°
for (int i = 0; i < 4; i++) {
teljesSzo.append(alkalmazSablon(betumatrix, aktualisSablon));
aktualisSablon = elforgatSablon(aktualisSablon);
}
return teljesSzo.toString();
}
/**
* 7. FELADATPONT (2p)
* Osztály bemutatása, metódusok meghívása demonstrációs céllal.
*/
public static void main(String[] args) {
System.out.println("==================================================");
System.out.println("1. TESZT: A feladatlapos példák ellenőrzése");
System.out.println("==================================================");
// A papíron látható betűmátrix deklarálása
char[][] peldaMatrix = {
{'T', 'I', 'M', 'T'},
{'I', 'P', 'C', 'K'},
{'I', 'U', 'R', 'A'},
{'T', 'C', 'O', 'S'}
};
// A papíron látható első sablon (két darab 1-es az első sor elején)
int[][] peldaSablonTITKOSIT = {
{1, 1, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
};
System.out.println("Teszt betűmátrix:\n" + matrixToString(peldaMatrix));
System.out.println("Teszt sablon (0 fok):\n" + sablonToString(peldaSablonTITKOSIT));
// Visszafejtés futtatása az első sablonra
String eredmeny1 = visszafejt(peldaMatrix, peldaSablonTITKOSIT);
System.out.println("Visszafejtett szó (Elvárt: TITKOSIT) -> " + eredmeny1);
// Második példa ellenőrzése: 1. sor 3. oszlopban van az egyetlen 1-es (0-s indexeléssel: [0][2])
int[][] peldaSablonMACI = {
{0, 0, 1, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
};
String eredmeny2 = visszafejt(peldaMatrix, peldaSablonMACI);
System.out.println("Visszafejtett szó (Elvárt: MACI) -> " + eredmeny2);
System.out.println("\n==================================================");
System.out.println("2. TESZT: Véletlenszerű generálások");
System.out.println("==================================================");
// Véletlenszerű betűmátrix generálása és kiírása
char[][] vMatrix = generalBetumatrix();
System.out.println("Generált véletlen betűmátrix:\n" + matrixToString(vMatrix));
// Véletlenszerű sablon generálása pontosan 3 darab 1-essel
int dbOnes = 3;
int[][] vSablon = generalSablon(dbOnes);
System.out.println("Generált sablon " + dbOnes + " db 1-essel:\n" + sablonToString(vSablon));
// Véletlenszerű mátrix visszafejtése a generált sablonnal
String vEredmeny = visszafejt(vMatrix, vSablon);
System.out.println("A generált adatokból visszafejtett titkos szó: " + vEredmeny);
System.out.println("A kapott szó hossza (szorzandó 4-gyel): " + vEredmeny.length() + " karakter.");
}
}