file_id
stringlengths 5
9
| repo
stringlengths 8
57
| token_length
int64 59
7.96k
| path
stringlengths 8
105
| content
stringlengths 147
30.2k
| original_comment
stringlengths 14
5.13k
| prompt
stringlengths 82
30.2k
| Included
stringclasses 1
value |
|---|---|---|---|---|---|---|---|
2507_1 | JakZostacProgramista/CvProgramisty-ProgramowanieObiektowe | 71 | src/encapsulation/car/Engine.java | package encapsulation.car;
/**
* Silnik samochodu.
*/
public class Engine {
/**
* Do tej metody dostęp powinien mieć tylko obiekt samochodu.
*/
public void startEngine() {/***/}
}
| /**
* Do tej metody dostęp powinien mieć tylko obiekt samochodu.
*/ | package encapsulation.car;
/**
* Silnik samochodu.
*/
public class Engine {
/**
* Do tej metody <SUF>*/
public void startEngine() {/***/}
}
| t |
9018_3 | Jaktaktonie/Java-samples | 791 | Java007/src/Main.java | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Address address = new Address("Legnica", "Sejmowa");
Male male1 = new Male("A", "Aa", 1, address);
Male male2 = new Male("Bb", "Bbb", 2, address);
Female female = new Female("Cc", "Ccc", 3, address);
Person[] persons = {male1, male2, female};
System.out.println("Dane wszystkich osób:");
for (Person person : persons) {
person.printDetails();
System.out.println();
}
System.out.println("Wiek przechodzenia na emeryturę:");
for (Person person : persons) {
System.out.println(person.getName() + " " + person.getSurname() + ": " + person.getRetirementAge());
}
System.out.println("Rok urodzenia:");
for (Person person : persons) {
System.out.println(person.getName() + " " + person.getSurname() + ": " + person.getBirthYear());
}
// Tworzenie listy females z obiektami klasy Female
ArrayList<Female> females = new ArrayList<>();
for (Person person : persons) {
if (person instanceof Female) {
females.add((Female) person);
}
}
// Sortowanie females po długości imienia w porządku rosnącym
Collections.sort(females, new Comparator<Female>() {
@Override
public int compare(Female f1, Female f2) {
return Integer.compare(f1.getName().length(), f2.getName().length());
}
});
System.out.println("Posortowane females według długości imienia (rosnąco):");
for (Female femalePerson : females) {
femalePerson.printDetails();
System.out.println();
}
// Liczenie liczby mężczyzn i kobiet w persons
int maleCount = 0;
int femaleCount = 0;
for (Person person : persons) {
if (person instanceof Male) {
maleCount++;
} else if (person instanceof Female) {
femaleCount++;
}
}
System.out.println("Liczba mężczyzn: " + maleCount);
System.out.println("Liczba kobiet: " + femaleCount);
// Tworzenie kopii obiektu male
Male male = new Male("D", "Dd", 4, address);
Male clonedMale = (Male) male.clone();
male.getAddress().setCity("TEST");
System.out.println("Dane obiektu male:");
male.printDetails();
System.out.println("Dane obiektu clonedMale:");
clonedMale.printDetails();
}
}
| // Tworzenie kopii obiektu male | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Address address = new Address("Legnica", "Sejmowa");
Male male1 = new Male("A", "Aa", 1, address);
Male male2 = new Male("Bb", "Bbb", 2, address);
Female female = new Female("Cc", "Ccc", 3, address);
Person[] persons = {male1, male2, female};
System.out.println("Dane wszystkich osób:");
for (Person person : persons) {
person.printDetails();
System.out.println();
}
System.out.println("Wiek przechodzenia na emeryturę:");
for (Person person : persons) {
System.out.println(person.getName() + " " + person.getSurname() + ": " + person.getRetirementAge());
}
System.out.println("Rok urodzenia:");
for (Person person : persons) {
System.out.println(person.getName() + " " + person.getSurname() + ": " + person.getBirthYear());
}
// Tworzenie listy females z obiektami klasy Female
ArrayList<Female> females = new ArrayList<>();
for (Person person : persons) {
if (person instanceof Female) {
females.add((Female) person);
}
}
// Sortowanie females po długości imienia w porządku rosnącym
Collections.sort(females, new Comparator<Female>() {
@Override
public int compare(Female f1, Female f2) {
return Integer.compare(f1.getName().length(), f2.getName().length());
}
});
System.out.println("Posortowane females według długości imienia (rosnąco):");
for (Female femalePerson : females) {
femalePerson.printDetails();
System.out.println();
}
// Liczenie liczby mężczyzn i kobiet w persons
int maleCount = 0;
int femaleCount = 0;
for (Person person : persons) {
if (person instanceof Male) {
maleCount++;
} else if (person instanceof Female) {
femaleCount++;
}
}
System.out.println("Liczba mężczyzn: " + maleCount);
System.out.println("Liczba kobiet: " + femaleCount);
// Tworzenie kopii <SUF>
Male male = new Male("D", "Dd", 4, address);
Male clonedMale = (Male) male.clone();
male.getAddress().setCity("TEST");
System.out.println("Dane obiektu male:");
male.printDetails();
System.out.println("Dane obiektu clonedMale:");
clonedMale.printDetails();
}
}
| t |
5682_0 | Jakub0627/KNPM | 361 | Java/kolekcje/src/Main.java | import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
System.out.println("Hello world!");
// generic tam gdzie możemy dostawiać typy <...>
LinkedList<String> grupa = new LinkedList<>();// zobacz gdzie String
grupa.add("Kowalski");
grupa.add("Nowak");
grupa.add("Adamowski");
Collections.sort(grupa);
for (String x: grupa){
System.out.println(x);
}
Student s1 = new Student("Adam", "Adamski");
s1.addOcena(5);
s1.addOcena(3);
Student s2 = new Student("Adam", "Adamski");
s2.addOcena(4);
s2.addOcena(4);
Student s3 = new Student("Adam", "Abba");
s3.addOcena(5);
s3.addOcena(4);
LinkedList<Student> grupaFull = new LinkedList<>();
grupaFull.add(s1);
grupaFull.add(s2);
grupaFull.add(s3);
Collections.sort(grupaFull);
System.out.println(grupaFull);
}
} | // generic tam gdzie możemy dostawiać typy <...> | import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
System.out.println("Hello world!");
// generic tam <SUF>
LinkedList<String> grupa = new LinkedList<>();// zobacz gdzie String
grupa.add("Kowalski");
grupa.add("Nowak");
grupa.add("Adamowski");
Collections.sort(grupa);
for (String x: grupa){
System.out.println(x);
}
Student s1 = new Student("Adam", "Adamski");
s1.addOcena(5);
s1.addOcena(3);
Student s2 = new Student("Adam", "Adamski");
s2.addOcena(4);
s2.addOcena(4);
Student s3 = new Student("Adam", "Abba");
s3.addOcena(5);
s3.addOcena(4);
LinkedList<Student> grupaFull = new LinkedList<>();
grupaFull.add(s1);
grupaFull.add(s2);
grupaFull.add(s3);
Collections.sort(grupaFull);
System.out.println(grupaFull);
}
} | t |
6376_0 | JakubZS4/Lipien-ZS4 | 802 | zdarzenia.Java | <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="style.css">
<title>ZD4</title>
</head>
<body>
<div>
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis quis molestie arcu. Proin a laoreet neque, sed mollis dui. Etiam a nulla et massa sollicitudin luctus. Curabitur nibh nibh, finibus luctus mollis non, consectetur a sapien. Proin viverra nunc a volutpat dapibus. Aenean euismod sem velit, eu rhoncus enim sollicitudin quis. Nunc pretium, erat sit amet tempus convallis, ligula turpis ullamcorper enim, et consequat nibh erat vel libero.
Donec interdum vitae lectus eget tempus. Praesent rutrum maximus mauris. Proin ante ipsum, lacinia nec scelerisque sit amet, venenatis vel elit. Donec tincidunt, sapien sed porttitor rutrum, sapien dui consectetur purus, ac congue dui felis id massa. Sed facilisis vitae nulla in porta. Morbi a ante nisl. Donec blandit augue augue, in tincidunt tellus sodales a. Nullam blandit malesuada sapien non auctor. Aliquam volutpat, diam ac vestibulum commodo, ante lectus consectetur purus, ac porttitor nisi dui eu tellus. In ipsum nunc, hendrerit non suscipit a, auctor a enim.
Quisque sollicitudin risus venenatis malesuada interdum. Aenean ut nunc diam. Proin non magna libero. Quisque eu congue orci.
</div>
<script>
function getRandomIntInclusive(min, max) {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min;
}
// Bierzemy diva
const div = document.querySelector('div');
const colors = ['red', 'green', 'orange', 'gray', 'white']
// Przypisujemy zdarzenie klikacz
div.addEventListener('click', (event)=>{
// Zmiana koloru czcionki
let los = getRandomIntInclusive(0,4);
div.style.color = colors[los];
});
// Zdarzenia
div.addEventListener('mouseover', (event)=>{
div.textContent = "Bardzo dobra robota";
});
div.addEventListener('mouseout', (event)=>{
div.textContent = "A elegancko";
});
</script>
</body>
</html>
| // Przypisujemy zdarzenie klikacz | <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="style.css">
<title>ZD4</title>
</head>
<body>
<div>
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis quis molestie arcu. Proin a laoreet neque, sed mollis dui. Etiam a nulla et massa sollicitudin luctus. Curabitur nibh nibh, finibus luctus mollis non, consectetur a sapien. Proin viverra nunc a volutpat dapibus. Aenean euismod sem velit, eu rhoncus enim sollicitudin quis. Nunc pretium, erat sit amet tempus convallis, ligula turpis ullamcorper enim, et consequat nibh erat vel libero.
Donec interdum vitae lectus eget tempus. Praesent rutrum maximus mauris. Proin ante ipsum, lacinia nec scelerisque sit amet, venenatis vel elit. Donec tincidunt, sapien sed porttitor rutrum, sapien dui consectetur purus, ac congue dui felis id massa. Sed facilisis vitae nulla in porta. Morbi a ante nisl. Donec blandit augue augue, in tincidunt tellus sodales a. Nullam blandit malesuada sapien non auctor. Aliquam volutpat, diam ac vestibulum commodo, ante lectus consectetur purus, ac porttitor nisi dui eu tellus. In ipsum nunc, hendrerit non suscipit a, auctor a enim.
Quisque sollicitudin risus venenatis malesuada interdum. Aenean ut nunc diam. Proin non magna libero. Quisque eu congue orci.
</div>
<script>
function getRandomIntInclusive(min, max) {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min;
}
// Bierzemy diva
const div = document.querySelector('div');
const colors = ['red', 'green', 'orange', 'gray', 'white']
// Przypisujemy zdarzenie <SUF>
div.addEventListener('click', (event)=>{
// Zmiana koloru czcionki
let los = getRandomIntInclusive(0,4);
div.style.color = colors[los];
});
// Zdarzenia
div.addEventListener('mouseover', (event)=>{
div.textContent = "Bardzo dobra robota";
});
div.addEventListener('mouseout', (event)=>{
div.textContent = "A elegancko";
});
</script>
</body>
</html>
| t |
3982_0 | JanMaciuk/SO_Lab_5 | 528 | src/Processor.java | import java.util.ArrayList;
public class Processor {
protected ArrayList<Task> waitingTasks;
protected ArrayList<Task> runningTasks;
protected ArrayList<Task> doneTasks;
protected ArrayList<Integer> loadHistory = new ArrayList<>();
public Processor(ArrayList<Task> tasks) {
waitingTasks = tasks;
runningTasks = new ArrayList<>();
doneTasks = new ArrayList<>();
}
public int currentLoad() {
int load = 0;
for (Task task : runningTasks) { load += task.load; }
return load;
}
public void doActiveTasks() {
runningTasks.forEach(task -> task.timeLeft--);
for (Task task: runningTasks) {
if (task.timeLeft <=0) doneTasks.add(task);
}
runningTasks.removeAll(doneTasks);
}
public boolean activateTask() {
if (waitingTasks.size() > 0) {
runningTasks.add(waitingTasks.remove(0));
return true;
}
else return false;
}
public Task getLatestTask() {
if (runningTasks.isEmpty()) return new Task(0,0); // Puste zadanie które nigdy się nie wykona, więc nie wpłynie na symulacje. (odpowiednik null-a)
return runningTasks.get(runningTasks.size() - 1);
}
public void reset() {
// Przywracam wszystkie zadania do oczekujących i resetuje ich czas wykonania.
waitingTasks.addAll(runningTasks);
runningTasks.clear();
waitingTasks.addAll(doneTasks);
doneTasks.clear();
waitingTasks.forEach(Task::reset);
}
public void logLoad() {
// Zapisuje obecne obciążenie procesora.
loadHistory.add(currentLoad());
}
public int getAverageLoad() {
int sum = 0;
for (Integer load : loadHistory) { sum += load; }
return sum / loadHistory.size();
}
}
| // Puste zadanie które nigdy się nie wykona, więc nie wpłynie na symulacje. (odpowiednik null-a) | import java.util.ArrayList;
public class Processor {
protected ArrayList<Task> waitingTasks;
protected ArrayList<Task> runningTasks;
protected ArrayList<Task> doneTasks;
protected ArrayList<Integer> loadHistory = new ArrayList<>();
public Processor(ArrayList<Task> tasks) {
waitingTasks = tasks;
runningTasks = new ArrayList<>();
doneTasks = new ArrayList<>();
}
public int currentLoad() {
int load = 0;
for (Task task : runningTasks) { load += task.load; }
return load;
}
public void doActiveTasks() {
runningTasks.forEach(task -> task.timeLeft--);
for (Task task: runningTasks) {
if (task.timeLeft <=0) doneTasks.add(task);
}
runningTasks.removeAll(doneTasks);
}
public boolean activateTask() {
if (waitingTasks.size() > 0) {
runningTasks.add(waitingTasks.remove(0));
return true;
}
else return false;
}
public Task getLatestTask() {
if (runningTasks.isEmpty()) return new Task(0,0); // Puste zadanie <SUF>
return runningTasks.get(runningTasks.size() - 1);
}
public void reset() {
// Przywracam wszystkie zadania do oczekujących i resetuje ich czas wykonania.
waitingTasks.addAll(runningTasks);
runningTasks.clear();
waitingTasks.addAll(doneTasks);
doneTasks.clear();
waitingTasks.forEach(Task::reset);
}
public void logLoad() {
// Zapisuje obecne obciążenie procesora.
loadHistory.add(currentLoad());
}
public int getAverageLoad() {
int sum = 0;
for (Integer load : loadHistory) { sum += load; }
return sum / loadHistory.size();
}
}
| t |
6890_11 | Jasiu-Code/Chapter2 | 1,089 | OOP/OOP-Day2/src/main/java/org/example/AdvancedCalculator.java | //Stwórz klasę AdvancedCalculator, która dziedziczy po klasie Calculator. Klasa powinna implementować następujące metody:
//
//pow(num1, num2) – metoda ma zwracać num1 do potęgi num2. Dodatkowo w tablicy operacji ma zapamiętać napis: "num1^num2 equals result".
//root(num1, num2) – metoda ma wyliczyć pierwiastek num2 stopni
//Do klasy AdvancedCalculator dopisz:
//
//stałą PI, która będzie miała przypisaną wartość 3.14159265,
//statyczną metodę computeCircleArea(r), która będzie zwracała pole koła. Ta metoda nie będzie dopisywać obliczeń do tablicy (napisz w komentarzu, dlaczego nie może tego robić),
//statyczną tablicę, która będzie przechowywała historię operacji wykonanych na wszystkich kalkulatorach,
//statyczną metodę printGlobalOperations(), która będzie wyświetlała wszystkie operacje ze wszystkich obiektów klasy AdvancedCalculator.
// ZAD 2
//Do klasy AdvancedCalculator dopisz:
//
//przeciążoną metodę printGlobalOperations(int length), która wyświetli określoną liczbę ostatnich operacji,
//przeciążoną metodę printGlobalOperations(String length), która wyświetli określoną liczbę ostatnich operacji.
package org.example;
import java.util.Arrays;
public class AdvancedCalculator extends Calculator {
final static double PI = 3.14159265;
static String[] globalArr = new String[0];
public double pow(double num1, double num2) {
double result = Math.pow(num1, num2);
addOperation(num1 + " ^ " + num2 + " equals " + result);
return result;
}
public double root(double num1, double num2) {
double result = Math.round(Math.pow(num1, (1 / num2)));
addOperation(num2 + " root of " + num1 + " equals " + result);
return result;
}
public static double computeCircleArea(double r) {
// metoda nie może dodawać do tablicy bo jest static, więc mozemy z niej korzystać bez utworzenia obiektu
// i przez to nie bedzie utworzona tablica
return 2 * PI * r;
}
@Override
public String[] addOperation(String text) {
String[] toReturn = super.addOperation(text);
globalArr = Arrays.copyOf(globalArr, globalArr.length + 1);
globalArr[globalArr.length - 1] = text;
return toReturn;
}
public static void printGlobalOperations() {
for (String item : globalArr) {
System.out.println(item);
}
}
public static void printGlobalOperations(int length) {
if (globalArr.length > length) {
for (int i = length; i > 0; i--) {
System.out.println(globalArr[globalArr.length - 1 - i]);
}
} else {
System.out.println("Array is not long enough");
for (String item : globalArr) {
System.out.println(item);
}
}
}
public static void printGlobalOperations(String length) {
try {
int len = Integer.parseInt(length);
if (globalArr.length > len) {
for (int i = len; i > 0; i--) {
System.out.println(globalArr[globalArr.length - 1 - i]);
}
} else {
System.out.println("Array is not long enough");
for (String item : globalArr) {
System.out.println(item);
}
}
} catch (NumberFormatException e) {
System.out.println("Wrong argument");
}
}
}
| // metoda nie może dodawać do tablicy bo jest static, więc mozemy z niej korzystać bez utworzenia obiektu | //Stwórz klasę AdvancedCalculator, która dziedziczy po klasie Calculator. Klasa powinna implementować następujące metody:
//
//pow(num1, num2) – metoda ma zwracać num1 do potęgi num2. Dodatkowo w tablicy operacji ma zapamiętać napis: "num1^num2 equals result".
//root(num1, num2) – metoda ma wyliczyć pierwiastek num2 stopni
//Do klasy AdvancedCalculator dopisz:
//
//stałą PI, która będzie miała przypisaną wartość 3.14159265,
//statyczną metodę computeCircleArea(r), która będzie zwracała pole koła. Ta metoda nie będzie dopisywać obliczeń do tablicy (napisz w komentarzu, dlaczego nie może tego robić),
//statyczną tablicę, która będzie przechowywała historię operacji wykonanych na wszystkich kalkulatorach,
//statyczną metodę printGlobalOperations(), która będzie wyświetlała wszystkie operacje ze wszystkich obiektów klasy AdvancedCalculator.
// ZAD 2
//Do klasy AdvancedCalculator dopisz:
//
//przeciążoną metodę printGlobalOperations(int length), która wyświetli określoną liczbę ostatnich operacji,
//przeciążoną metodę printGlobalOperations(String length), która wyświetli określoną liczbę ostatnich operacji.
package org.example;
import java.util.Arrays;
public class AdvancedCalculator extends Calculator {
final static double PI = 3.14159265;
static String[] globalArr = new String[0];
public double pow(double num1, double num2) {
double result = Math.pow(num1, num2);
addOperation(num1 + " ^ " + num2 + " equals " + result);
return result;
}
public double root(double num1, double num2) {
double result = Math.round(Math.pow(num1, (1 / num2)));
addOperation(num2 + " root of " + num1 + " equals " + result);
return result;
}
public static double computeCircleArea(double r) {
// metoda nie <SUF>
// i przez to nie bedzie utworzona tablica
return 2 * PI * r;
}
@Override
public String[] addOperation(String text) {
String[] toReturn = super.addOperation(text);
globalArr = Arrays.copyOf(globalArr, globalArr.length + 1);
globalArr[globalArr.length - 1] = text;
return toReturn;
}
public static void printGlobalOperations() {
for (String item : globalArr) {
System.out.println(item);
}
}
public static void printGlobalOperations(int length) {
if (globalArr.length > length) {
for (int i = length; i > 0; i--) {
System.out.println(globalArr[globalArr.length - 1 - i]);
}
} else {
System.out.println("Array is not long enough");
for (String item : globalArr) {
System.out.println(item);
}
}
}
public static void printGlobalOperations(String length) {
try {
int len = Integer.parseInt(length);
if (globalArr.length > len) {
for (int i = len; i > 0; i--) {
System.out.println(globalArr[globalArr.length - 1 - i]);
}
} else {
System.out.println("Array is not long enough");
for (String item : globalArr) {
System.out.println(item);
}
}
} catch (NumberFormatException e) {
System.out.println("Wrong argument");
}
}
}
| t |
2435_1 | Java2016-2017-grupa-1/MaplePlugin | 414 | MapleViaJava/MapleTerminal.java | import com.maplesoft.openmaple.*;
import com.maplesoft.externalcall.MapleException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
public class MapleTerminal {
private static MapleTerminal instance = null;
private String a[];
private Engine t;
private String answer;
private PrintStream dummyStream;
private MapleTerminal(){
try{
a = new String[1];
a[0] = "java";
t = new Engine( a, new EngineCallBacksDefault(), null, null ); // Mozna uruchomić tylko jeden silnik naraz (dlatego singleton)
dummyStream = new PrintStream(new OutputStream() { // evaluate jest napisane tak, ze wypisuje wynik, dummy stream sluzy do blokowania tego
@Override
public void write(int b) throws IOException {
}
});
}
catch (MapleException e){
System.out.println(e.getMessage());
}
}
public static MapleTerminal getInstance(){
if (instance == null) instance = new MapleTerminal();
return instance;
}
public String evaluate(String query){
try{
PrintStream originalStream = System.out;
System.setOut(dummyStream);
answer = String.valueOf(t.evaluate(query));
System.setOut(originalStream);
}
catch (MapleException e){ // lapie wyjatki prosto z Maple
answer = e.getMessage();
}
return answer;
}
}
| // evaluate jest napisane tak, ze wypisuje wynik, dummy stream sluzy do blokowania tego | import com.maplesoft.openmaple.*;
import com.maplesoft.externalcall.MapleException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
public class MapleTerminal {
private static MapleTerminal instance = null;
private String a[];
private Engine t;
private String answer;
private PrintStream dummyStream;
private MapleTerminal(){
try{
a = new String[1];
a[0] = "java";
t = new Engine( a, new EngineCallBacksDefault(), null, null ); // Mozna uruchomić tylko jeden silnik naraz (dlatego singleton)
dummyStream = new PrintStream(new OutputStream() { // evaluate jest <SUF>
@Override
public void write(int b) throws IOException {
}
});
}
catch (MapleException e){
System.out.println(e.getMessage());
}
}
public static MapleTerminal getInstance(){
if (instance == null) instance = new MapleTerminal();
return instance;
}
public String evaluate(String query){
try{
PrintStream originalStream = System.out;
System.setOut(dummyStream);
answer = String.valueOf(t.evaluate(query));
System.setOut(originalStream);
}
catch (MapleException e){ // lapie wyjatki prosto z Maple
answer = e.getMessage();
}
return answer;
}
}
| t |
10346_0 | Jeremylaby/PO_2023_PROJ_BARYCKI_KASPRZYCKI | 1,516 | darwin_world/src/main/java/agh/ics/oop/model/map/AbstractWorldMap.java | package agh.ics.oop.model.map;
import agh.ics.oop.model.configuration.Configuration;
import agh.ics.oop.model.Vector2d;
import agh.ics.oop.model.elements.Animal;
import agh.ics.oop.model.elements.AnimalsFactory;
import agh.ics.oop.model.elements.Plant;
import agh.ics.oop.model.elements.WorldElement;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;
public abstract class AbstractWorldMap implements WorldMap {
private final Map<Vector2d, Set<Animal>> animals;
protected final Map<Vector2d, Plant> plants;
protected final Configuration config;
private final AnimalsFactory animalsFactory;
private int sumOfSurvivedDays=0;
private int sumOfDeadAnimals=0;
public AbstractWorldMap(Configuration configuration, AnimalsFactory animalsFactory) {
config = configuration;
this.animalsFactory = animalsFactory;
animals = new ConcurrentHashMap<>(config.mapWidth()*config.mapHeight());
plants = new ConcurrentHashMap<>(config.mapWidth()*config.mapHeight());
}
protected abstract void generatePlants(int numOfPlants);
protected void removePlant(Vector2d position) {
plants.remove(position);
}
private Optional<Animal> findStrongestExcept(Set<Animal> animals, Animal exceptAnimal) {
return animals.stream()
.filter(animal -> !Objects.equals(animal, exceptAnimal))
.max(Comparator
.comparingInt(Animal::getEnergy)
.thenComparing(Animal::getAge)
.thenComparing(Animal::getKidsNumber));
}
private Optional<Animal> findStrongest(Set<Animal> animals) {
return findStrongestExcept(animals, null);
}
public void place(Animal animal) {
if (!isAnimal(animal.getPosition())) {
animals.put(animal.getPosition(), new HashSet<>());
}
animals.get(animal.getPosition()).add(animal);
}
@Override
public void move(Animal animal) {
animalsAt(animal.getPosition())
.ifPresent(animalsAtPosition -> {
if (animalsAtPosition.contains(animal)) {
remove(animal);
animal.move(config.mapWidth(), config.mapHeight());
place(animal);
}
});
}
@Override
public void remove(Animal animal) {
animalsAt(animal.getPosition())
.ifPresent(animalsAtPosition -> {
animalsAtPosition.remove(animal);
if (animalsAtPosition.isEmpty()) {
animals.remove(animal.getPosition());
}
});
}
public void feedAnimals() {
animals.forEach((position, animalsAtPosition) -> {
if (plants.containsKey(position)) {
findStrongest(animalsAtPosition).ifPresent(this::feedAnimal);
removePlant(position);
}
});
}
protected void feedAnimal(Animal animal) {//będę nadpisywał w poisoned land
animal.eat(config.plantsEnergyValue());
}
public boolean isAnimal(Vector2d position) {
return animals.containsKey(position);
}
@Override
public Optional<Set<Animal>> animalsAt(Vector2d position) {
return Optional.ofNullable(animals.get(position));
}
@Override
public List<Animal> reproduceAnimals() {
List<Animal> newborns = new ArrayList<>();
for (Set<Animal> animalSet: animals.values()) {
findStrongest(animalSet).ifPresent(father -> {
findStrongestExcept(animalSet, father).ifPresent(mother -> {
if (canAnimalReproduce(father) && canAnimalReproduce(mother)) {
Animal child = animalsFactory.makeChild(father, mother);
place(child);
newborns.add(child);
}
});
});
}
return newborns;
}
@Override
public void growPlants() {
generatePlants(config.plantsNumPerDay());
}
public void removeDeadAnimal(Animal animal, int dayOfSimulation){
animal.die(dayOfSimulation);
sumOfSurvivedDays += animal.getAge();
sumOfDeadAnimals += 1;
remove(animal);
}
private boolean canAnimalReproduce(Animal animal) {
return animal.getEnergy() >= config.animalsEnergyToReproduce();
}
@Override
public Stream<WorldElement> getElements() {
return Stream.concat(
plants.values().stream().filter(plant -> !isAnimal(plant.getPosition())),
animals.values().stream().map(this::findStrongest).map(Optional::get)
);
}
public Map<Vector2d, Plant> getPlants() {
return Collections.unmodifiableMap(plants);
}
public Map<Vector2d, Set<Animal>> getAnimals() {
return Collections.unmodifiableMap(animals);
}
@Override
public int getWidth() {
return config.mapWidth();
}
@Override
public int getHeight() {
return config.mapHeight();
}
public int getSumOfSurvivedDays() {
return sumOfSurvivedDays;
}
public int getSumOfDeadAnimals() {
return sumOfDeadAnimals;
}
}
| //będę nadpisywał w poisoned land | package agh.ics.oop.model.map;
import agh.ics.oop.model.configuration.Configuration;
import agh.ics.oop.model.Vector2d;
import agh.ics.oop.model.elements.Animal;
import agh.ics.oop.model.elements.AnimalsFactory;
import agh.ics.oop.model.elements.Plant;
import agh.ics.oop.model.elements.WorldElement;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;
public abstract class AbstractWorldMap implements WorldMap {
private final Map<Vector2d, Set<Animal>> animals;
protected final Map<Vector2d, Plant> plants;
protected final Configuration config;
private final AnimalsFactory animalsFactory;
private int sumOfSurvivedDays=0;
private int sumOfDeadAnimals=0;
public AbstractWorldMap(Configuration configuration, AnimalsFactory animalsFactory) {
config = configuration;
this.animalsFactory = animalsFactory;
animals = new ConcurrentHashMap<>(config.mapWidth()*config.mapHeight());
plants = new ConcurrentHashMap<>(config.mapWidth()*config.mapHeight());
}
protected abstract void generatePlants(int numOfPlants);
protected void removePlant(Vector2d position) {
plants.remove(position);
}
private Optional<Animal> findStrongestExcept(Set<Animal> animals, Animal exceptAnimal) {
return animals.stream()
.filter(animal -> !Objects.equals(animal, exceptAnimal))
.max(Comparator
.comparingInt(Animal::getEnergy)
.thenComparing(Animal::getAge)
.thenComparing(Animal::getKidsNumber));
}
private Optional<Animal> findStrongest(Set<Animal> animals) {
return findStrongestExcept(animals, null);
}
public void place(Animal animal) {
if (!isAnimal(animal.getPosition())) {
animals.put(animal.getPosition(), new HashSet<>());
}
animals.get(animal.getPosition()).add(animal);
}
@Override
public void move(Animal animal) {
animalsAt(animal.getPosition())
.ifPresent(animalsAtPosition -> {
if (animalsAtPosition.contains(animal)) {
remove(animal);
animal.move(config.mapWidth(), config.mapHeight());
place(animal);
}
});
}
@Override
public void remove(Animal animal) {
animalsAt(animal.getPosition())
.ifPresent(animalsAtPosition -> {
animalsAtPosition.remove(animal);
if (animalsAtPosition.isEmpty()) {
animals.remove(animal.getPosition());
}
});
}
public void feedAnimals() {
animals.forEach((position, animalsAtPosition) -> {
if (plants.containsKey(position)) {
findStrongest(animalsAtPosition).ifPresent(this::feedAnimal);
removePlant(position);
}
});
}
protected void feedAnimal(Animal animal) {//będę nadpisywał <SUF>
animal.eat(config.plantsEnergyValue());
}
public boolean isAnimal(Vector2d position) {
return animals.containsKey(position);
}
@Override
public Optional<Set<Animal>> animalsAt(Vector2d position) {
return Optional.ofNullable(animals.get(position));
}
@Override
public List<Animal> reproduceAnimals() {
List<Animal> newborns = new ArrayList<>();
for (Set<Animal> animalSet: animals.values()) {
findStrongest(animalSet).ifPresent(father -> {
findStrongestExcept(animalSet, father).ifPresent(mother -> {
if (canAnimalReproduce(father) && canAnimalReproduce(mother)) {
Animal child = animalsFactory.makeChild(father, mother);
place(child);
newborns.add(child);
}
});
});
}
return newborns;
}
@Override
public void growPlants() {
generatePlants(config.plantsNumPerDay());
}
public void removeDeadAnimal(Animal animal, int dayOfSimulation){
animal.die(dayOfSimulation);
sumOfSurvivedDays += animal.getAge();
sumOfDeadAnimals += 1;
remove(animal);
}
private boolean canAnimalReproduce(Animal animal) {
return animal.getEnergy() >= config.animalsEnergyToReproduce();
}
@Override
public Stream<WorldElement> getElements() {
return Stream.concat(
plants.values().stream().filter(plant -> !isAnimal(plant.getPosition())),
animals.values().stream().map(this::findStrongest).map(Optional::get)
);
}
public Map<Vector2d, Plant> getPlants() {
return Collections.unmodifiableMap(plants);
}
public Map<Vector2d, Set<Animal>> getAnimals() {
return Collections.unmodifiableMap(animals);
}
@Override
public int getWidth() {
return config.mapWidth();
}
@Override
public int getHeight() {
return config.mapHeight();
}
public int getSumOfSurvivedDays() {
return sumOfSurvivedDays;
}
public int getSumOfDeadAnimals() {
return sumOfDeadAnimals;
}
}
| t |
9119_6 | Jowitam/simple-booking | 739 | src/main/java/com/github/jowitam/BookingControler.java | package com.github.jowitam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDate;
import java.util.List;
/**
* Controler w którym jest metoda GET i POST
* dla GET dla zasobu /booking wroci wynik {"available": true}
* dla POST możliwa jest rezerwacja pokoju (informacja przesłana JSON)
*/
@RestController
public class BookingControler {
@Autowired//spring wstrzyknie obiekt bedacy implementacja tego interfejsu
private ReservationRepository repository;
@RequestMapping("/booking")
public Booking booking(@RequestParam("from") @DateTimeFormat(pattern = "ddMMyyyy") LocalDate from,
@RequestParam("to") @DateTimeFormat(pattern = "ddMMyyyy") LocalDate to) {
/**
*aby sprawdzic dostepnosc dla podanego zakresu od do muszę po kolei dla podanych liczb
* z zakresu sprawdzić na liście rezerwacji czy tam wystepują jak jakakolwiek
* jest to dostepnosci brak
*/
if (!from.isBefore(to)) {//jezeli nie prawda jest ze from jest przed to
throw new WrongDateRangeException(from, to); //WYJATEK wyrzucenie nowego wyjatku ktory jest obslugiwany przez Springa - pisany w osobnej klasie
}
List<Reservation> listReservation = repository.findByReservationDataBetween(from, to.minusDays(1));
if(listReservation.size() == 0){
return new Booking(true);
}else{
return new Booking(false);
}
}
/**
* rezerwacja po przez wysłanie POST w formacie JSON
*/
@RequestMapping(value = "/booking", method = RequestMethod.POST)
public void createBooking(@RequestBody NewBooking newBooking) {
LocalDate now = LocalDate.now();
LocalDate from = newBooking.getFrom();
if (from.isBefore(now)) {
throw new WrongDateRangeException(from);
}
if (booking(newBooking.getFrom(), newBooking.getTo()).getAvailable()){
for (LocalDate day = newBooking.getFrom(); day.isBefore(newBooking.getTo()); day = day.plusDays(1)) {
repository.save(new Reservation(day));
}
} else {
throw new ReservedRoomException();//WYJATEK ze pokoj jest zarezerwowany
}
}
}
| //WYJATEK ze pokoj jest zarezerwowany
| package com.github.jowitam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDate;
import java.util.List;
/**
* Controler w którym jest metoda GET i POST
* dla GET dla zasobu /booking wroci wynik {"available": true}
* dla POST możliwa jest rezerwacja pokoju (informacja przesłana JSON)
*/
@RestController
public class BookingControler {
@Autowired//spring wstrzyknie obiekt bedacy implementacja tego interfejsu
private ReservationRepository repository;
@RequestMapping("/booking")
public Booking booking(@RequestParam("from") @DateTimeFormat(pattern = "ddMMyyyy") LocalDate from,
@RequestParam("to") @DateTimeFormat(pattern = "ddMMyyyy") LocalDate to) {
/**
*aby sprawdzic dostepnosc dla podanego zakresu od do muszę po kolei dla podanych liczb
* z zakresu sprawdzić na liście rezerwacji czy tam wystepują jak jakakolwiek
* jest to dostepnosci brak
*/
if (!from.isBefore(to)) {//jezeli nie prawda jest ze from jest przed to
throw new WrongDateRangeException(from, to); //WYJATEK wyrzucenie nowego wyjatku ktory jest obslugiwany przez Springa - pisany w osobnej klasie
}
List<Reservation> listReservation = repository.findByReservationDataBetween(from, to.minusDays(1));
if(listReservation.size() == 0){
return new Booking(true);
}else{
return new Booking(false);
}
}
/**
* rezerwacja po przez wysłanie POST w formacie JSON
*/
@RequestMapping(value = "/booking", method = RequestMethod.POST)
public void createBooking(@RequestBody NewBooking newBooking) {
LocalDate now = LocalDate.now();
LocalDate from = newBooking.getFrom();
if (from.isBefore(now)) {
throw new WrongDateRangeException(from);
}
if (booking(newBooking.getFrom(), newBooking.getTo()).getAvailable()){
for (LocalDate day = newBooking.getFrom(); day.isBefore(newBooking.getTo()); day = day.plusDays(1)) {
repository.save(new Reservation(day));
}
} else {
throw new ReservedRoomException();//WYJATEK ze <SUF>
}
}
}
| t |
8245_0 | Jozek2023/algorytm_mrowkowy_sztuczna_inteligencja | 360 | src/service/RouteProbabilityCounter.java | package service;
import data.DistanceToCity;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class RouteProbabilityCounter {
public DistanceToCity chooseCityToGoToNext(List<DistanceToCity> distanceToCities, int a, int b) {
double total = 0.0;
Map<DistanceToCity, Double> rankForRouteToCity = new HashMap<>();
for (DistanceToCity distanceToCity : distanceToCities) {
double rank = countRoute(distanceToCity, a, b);
rankForRouteToCity.put(distanceToCity, rank);
total += rank;
}
double randomTreshold = Math.random();
double cumulativeProbability = 0.0;
for (DistanceToCity distanceToCity : distanceToCities) {
cumulativeProbability += (rankForRouteToCity.get(distanceToCity) / total);
if (randomTreshold <= cumulativeProbability)
return distanceToCity;
}
throw new IndexOutOfBoundsException("Brak miast do odwiedzenia."); //błąd nie powinien nigdy wystąpić.
}
private double countRoute(DistanceToCity d1, int a, int b) {
return Math.pow(d1.getPheromoneLevel(), a) * Math.pow(d1.getDistanceTo(), b);
}
}
| //błąd nie powinien nigdy wystąpić. | package service;
import data.DistanceToCity;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class RouteProbabilityCounter {
public DistanceToCity chooseCityToGoToNext(List<DistanceToCity> distanceToCities, int a, int b) {
double total = 0.0;
Map<DistanceToCity, Double> rankForRouteToCity = new HashMap<>();
for (DistanceToCity distanceToCity : distanceToCities) {
double rank = countRoute(distanceToCity, a, b);
rankForRouteToCity.put(distanceToCity, rank);
total += rank;
}
double randomTreshold = Math.random();
double cumulativeProbability = 0.0;
for (DistanceToCity distanceToCity : distanceToCities) {
cumulativeProbability += (rankForRouteToCity.get(distanceToCity) / total);
if (randomTreshold <= cumulativeProbability)
return distanceToCity;
}
throw new IndexOutOfBoundsException("Brak miast do odwiedzenia."); //błąd nie <SUF>
}
private double countRoute(DistanceToCity d1, int a, int b) {
return Math.pow(d1.getPheromoneLevel(), a) * Math.pow(d1.getDistanceTo(), b);
}
}
| t |
9336_2 | Js111l/PZU-Java-Challenge | 1,238 | src/com/company/Default_Code.java | package com.company;
import java.io.*;
import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collector;
import java.util.stream.Collectors;
// 1.każde miasto i usługa były pozbawione pustych znaków z przodu i z tyłu
// 2.prawidłowo grupował usługi nawet jeśli ich definicje powtarzają się w kilku linijkach i są pisane literami różnej wielkości (sprowadzał nazwy usług i miast do małych liter)
// 3.usuwał duplikaty usług w ramach jednego miasta, nawet jeśli są one pisane literami różnej wielkości
// 4.ignorował puste linie
// 5.ignorował linie które zaczynają się od słowa SKIP
// 6.działał zgodnie z przykładem
public class Default_Code {
public static void main(String[] args) throws IOException {
String input = "SKIPwarszawa;oc;zdrowotne\n"
+ "bielsko-biała;na życie ;od powodzi\n"
+ "łódź; od ognia;OD NIESZCZĘŚLIWYCH WYPADKÓW;ac\n\n"
+ " ŁÓDŹ;domu;na wypadek straty pracy;Ac";
InputStream inputStream = new java.io.ByteArrayInputStream(input.getBytes());
InsuranceServiceGrouping grouping = new InsuranceServiceGrouping();
Map<String, String[]> output = grouping.processFile(inputStream);
}
}
class InsuranceServiceGrouping {
Map<String, String[]> processFile(InputStream inputStream) throws IOException {
Predicate<String> filter = x -> x.substring(1, 4) != "SKIP";
Function<String, String[]> mapper = line -> Arrays.stream(line.split(";")).toArray(String[]::new);
Collector<String[], ?, Map<String, String[]>> collector = Collectors.toMap(elem -> elem[0],
elem -> new String[] { elem[1], elem[2] });
StreamProcessor processor = new StreamProcessor.StreamProcessorBuilder().filter(filter).mapper(mapper)
.collector(collector).build();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
return processFile(bufferedReader, processor);
}
Map<String, String[]> processFile(BufferedReader bufferedReader, StreamProcessor processor) throws IOException {
int c=0;
StringBuilder stringBuilder=new StringBuilder();
while ((c=bufferedReader.read())!=-1){
stringBuilder.append((char)c);
}
String word=stringBuilder.toString();
return word.lines().filter(processor.getFilter()).map(processor.getMapper())
.collect(processor.getCollector());
}
}
class StreamProcessor {
private final Predicate<String> filter;
private final Function<String, String[]> mapper;
private final Collector<String[], ?, Map<String, String[]>> collector;
StreamProcessor() {
this.filter = null;
this.mapper = null;
this.collector = null;
}
StreamProcessor(StreamProcessorBuilder builder) {
this.filter = builder.filter;
this.mapper = builder.mapper;
this.collector = builder.collector;
}
public static class StreamProcessorBuilder {
private Predicate<String> filter;
private Function<String, String[]> mapper;
private Collector<String[], ?, Map<String, String[]>> collector;
StreamProcessorBuilder filter(Predicate<String> filter) {
this.filter = filter;
return this;
}
StreamProcessorBuilder mapper(Function<String, String[]> mapper) {
this.mapper = mapper;
return this;
}
StreamProcessorBuilder collector(Collector<String[], ?, Map<String, String[]>> collector) {
this.collector = collector;
return this;
}
StreamProcessor build() {
return new StreamProcessor(this);
}
}
Predicate<String> getFilter() {
return filter;
}
Function<String, String[]> getMapper() {
return mapper;
}
Collector<String[], ?, Map<String, String[]>> getCollector() {
return collector;
}
}
| // 3.usuwał duplikaty usług w ramach jednego miasta, nawet jeśli są one pisane literami różnej wielkości
| package com.company;
import java.io.*;
import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collector;
import java.util.stream.Collectors;
// 1.każde miasto i usługa były pozbawione pustych znaków z przodu i z tyłu
// 2.prawidłowo grupował usługi nawet jeśli ich definicje powtarzają się w kilku linijkach i są pisane literami różnej wielkości (sprowadzał nazwy usług i miast do małych liter)
// 3.usuwał duplikaty <SUF>
// 4.ignorował puste linie
// 5.ignorował linie które zaczynają się od słowa SKIP
// 6.działał zgodnie z przykładem
public class Default_Code {
public static void main(String[] args) throws IOException {
String input = "SKIPwarszawa;oc;zdrowotne\n"
+ "bielsko-biała;na życie ;od powodzi\n"
+ "łódź; od ognia;OD NIESZCZĘŚLIWYCH WYPADKÓW;ac\n\n"
+ " ŁÓDŹ;domu;na wypadek straty pracy;Ac";
InputStream inputStream = new java.io.ByteArrayInputStream(input.getBytes());
InsuranceServiceGrouping grouping = new InsuranceServiceGrouping();
Map<String, String[]> output = grouping.processFile(inputStream);
}
}
class InsuranceServiceGrouping {
Map<String, String[]> processFile(InputStream inputStream) throws IOException {
Predicate<String> filter = x -> x.substring(1, 4) != "SKIP";
Function<String, String[]> mapper = line -> Arrays.stream(line.split(";")).toArray(String[]::new);
Collector<String[], ?, Map<String, String[]>> collector = Collectors.toMap(elem -> elem[0],
elem -> new String[] { elem[1], elem[2] });
StreamProcessor processor = new StreamProcessor.StreamProcessorBuilder().filter(filter).mapper(mapper)
.collector(collector).build();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
return processFile(bufferedReader, processor);
}
Map<String, String[]> processFile(BufferedReader bufferedReader, StreamProcessor processor) throws IOException {
int c=0;
StringBuilder stringBuilder=new StringBuilder();
while ((c=bufferedReader.read())!=-1){
stringBuilder.append((char)c);
}
String word=stringBuilder.toString();
return word.lines().filter(processor.getFilter()).map(processor.getMapper())
.collect(processor.getCollector());
}
}
class StreamProcessor {
private final Predicate<String> filter;
private final Function<String, String[]> mapper;
private final Collector<String[], ?, Map<String, String[]>> collector;
StreamProcessor() {
this.filter = null;
this.mapper = null;
this.collector = null;
}
StreamProcessor(StreamProcessorBuilder builder) {
this.filter = builder.filter;
this.mapper = builder.mapper;
this.collector = builder.collector;
}
public static class StreamProcessorBuilder {
private Predicate<String> filter;
private Function<String, String[]> mapper;
private Collector<String[], ?, Map<String, String[]>> collector;
StreamProcessorBuilder filter(Predicate<String> filter) {
this.filter = filter;
return this;
}
StreamProcessorBuilder mapper(Function<String, String[]> mapper) {
this.mapper = mapper;
return this;
}
StreamProcessorBuilder collector(Collector<String[], ?, Map<String, String[]>> collector) {
this.collector = collector;
return this;
}
StreamProcessor build() {
return new StreamProcessor(this);
}
}
Predicate<String> getFilter() {
return filter;
}
Function<String, String[]> getMapper() {
return mapper;
}
Collector<String[], ?, Map<String, String[]>> getCollector() {
return collector;
}
}
| t |
7155_1 | Jullija/ProgramowanieObiektowe | 602 | lab5/oolab/src/main/java/agh/ics/oop/Vector2d.java | package agh.ics.oop;
import java.util.Objects;
public class Vector2d {
final int x; //final -> nie ma możliwości zmiany danych
final int y;
public Vector2d(int x, int y) {
this.x = x;
this.y = y;
}
public Vector2d add(Vector2d other){
return new Vector2d(x + other.x, y + other.y);
}
public Vector2d subtract(Vector2d other){
return new Vector2d(x - other.x, y - other.y);
}
public Vector2d upperRight(Vector2d other){
return new Vector2d(Math.max(x, other.x), Math.max(y, other.y));
}
public Vector2d lowerLeft(Vector2d other){
return new Vector2d(Math.min(x, other.x), Math.min(y, other.y));
}
public Vector2d opposite(){
return new Vector2d(-x, -y);
}
@Override
public boolean equals(Object other){ //dostaję Object other i zwraca mi bool
if (this == other){ //jeśli mój wektor i other mają ten sam adres
return true;
}
if (!(other instanceof Vector2d)){ //jeśli other nie jest zgodny z typem Vector2d
return false;
}
Vector2d newVector = (Vector2d) other; //zamieniam object other na wektor typu vector2d
if (newVector.x == x && newVector.y == y){
return true;
}else{
return false;
}
}
@Override
public int hashCode(){
return Objects.hash(x, y);
}
@Override //odziedziczona metoda z klasy typu object
public String toString() {
return "(%d, %d)".formatted(x, y); //%d -> int
}
boolean precedes(Vector2d other){
return x <= other.x && y <= other.y;
}
boolean follows(Vector2d other){
return x >= other.x && y >= other.y;
}
} | //dostaję Object other i zwraca mi bool | package agh.ics.oop;
import java.util.Objects;
public class Vector2d {
final int x; //final -> nie ma możliwości zmiany danych
final int y;
public Vector2d(int x, int y) {
this.x = x;
this.y = y;
}
public Vector2d add(Vector2d other){
return new Vector2d(x + other.x, y + other.y);
}
public Vector2d subtract(Vector2d other){
return new Vector2d(x - other.x, y - other.y);
}
public Vector2d upperRight(Vector2d other){
return new Vector2d(Math.max(x, other.x), Math.max(y, other.y));
}
public Vector2d lowerLeft(Vector2d other){
return new Vector2d(Math.min(x, other.x), Math.min(y, other.y));
}
public Vector2d opposite(){
return new Vector2d(-x, -y);
}
@Override
public boolean equals(Object other){ //dostaję Object <SUF>
if (this == other){ //jeśli mój wektor i other mają ten sam adres
return true;
}
if (!(other instanceof Vector2d)){ //jeśli other nie jest zgodny z typem Vector2d
return false;
}
Vector2d newVector = (Vector2d) other; //zamieniam object other na wektor typu vector2d
if (newVector.x == x && newVector.y == y){
return true;
}else{
return false;
}
}
@Override
public int hashCode(){
return Objects.hash(x, y);
}
@Override //odziedziczona metoda z klasy typu object
public String toString() {
return "(%d, %d)".formatted(x, y); //%d -> int
}
boolean precedes(Vector2d other){
return x <= other.x && y <= other.y;
}
boolean follows(Vector2d other){
return x >= other.x && y >= other.y;
}
} | t |
3407_0 | JuraGrzegorz/PoliPoly | 1,864 | src/MainWindow.java | import javax.swing.*;
import java.awt.*;
import java.io.IOException;
import java.net.Socket;
public class MainWindow {
private final JFrame window;
private static final int BUTTONFONTSIZE = 16;
private Server server;
private Client client;
boolean gameStarted;
boolean stopHostingGame;
private final NickNameTakenWindow alertWindow;
public MainWindow(){
gameStarted=false;
stopHostingGame=false;
MenuWindow menuWindow=new MenuWindow();
alertWindow=new NickNameTakenWindow();
Player player=new Player();
JPanel container;
// Tworzenie panelu Container
container = new JPanel() {
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
ImageIcon menuBackground = new ImageIcon("assets/tmp_bg.png");
g.drawImage(menuBackground.getImage(), 0, 0, null);
}
};
container.setLayout(new BoxLayout(container, BoxLayout.Y_AXIS));
menuWindow.logoLabel.setBorder(BorderFactory.createEmptyBorder(60, 0, 0, 0));
container.add(menuWindow.logoLabel);
container.add(menuWindow.mainMenu);
container.add(menuWindow.menuHostGame, BorderLayout.NORTH);
container.add(menuWindow.menuJoinGame);
menuWindow.menuPlay.setVisible(false);
menuWindow.menuHostGame.setVisible(false);
menuWindow.menuJoinGame.setVisible(false);
container.add(menuWindow.menuPlay);
//akcje przycisków
menuWindow.playButton.addActionListener(back -> {
menuWindow.mainMenu.setVisible(false);
menuWindow.menuPlay.setVisible(true);
});
menuWindow.enterJoinMenuButton.addActionListener(back -> {
menuWindow.menuPlay.setVisible(false);
menuWindow.menuJoinGame.setVisible(true);
});
menuWindow.joinGameButton.addActionListener(back -> {
if(!player.playerConnected){
try {
client=new Client();
client.ClientConnect(menuWindow.ipAddressGetTextField.getText(),8080);
client.SetCommunicationParameters(client.clientSocket);
player.PlayerConnect();
ClientReadFromServer clientReadFromServer=new ClientReadFromServer(client,menuWindow,menuWindow.joinGameListButtons,alertWindow,player);
clientReadFromServer.start();
client.fromClient.println("setNickname:"+menuWindow.nickNameTextFieldJoinMenu.getText());
} catch (IOException e) {
}
}else{
alertWindow.setMessage("Jesteś juz w lobby!!");
alertWindow.show();
}
});
menuWindow.enterHostMenuButton.addActionListener(back -> {
server=new Server();
synchronized (this) {
stopHostingGame=false;
}
try {
server.openSocket(8080);
server.serverSocketChannel.setSoTimeout(1000);
} catch (IOException e) {
alertWindow.setMessage("Server juz istnieje!");
alertWindow.show();
return;
}
menuWindow.menuPlay.setVisible(false);
menuWindow.menuHostGame.setVisible(true);
Thread ThreadWaitingForPlayers = new Thread(() -> {
ServerMainThread serverMainThread=new ServerMainThread(server);
serverMainThread.start();
while (true){
synchronized (this) {
if(gameStarted || stopHostingGame){
break;
}
}
Socket tmp_clientSock = null;
try {
tmp_clientSock = server.serverSocketChannel.accept();
server.addSemaphore();
Communication tmp_Comm=server.listOfCommunication.get(server.listOfCommunication.size()-1);
ServerReadFromClient serverReadThread=new ServerReadFromClient(tmp_clientSock,tmp_Comm,server.syncJoiningPlayers);
serverReadThread.start();
ServerWriteTOClient serverWriteThread=new ServerWriteTOClient(tmp_clientSock,tmp_Comm);
serverWriteThread.start();
} catch (IOException e) {}
}
});
ThreadWaitingForPlayers.start();
while (true){
try {
client=new Client();
client.ClientConnect("localhost",8080);
client.SetCommunicationParameters(client.clientSocket);
ClientReadFromServer clientReadFromServer=new ClientReadFromServer(client,menuWindow,menuWindow.hostGameListButtons,alertWindow,player);
clientReadFromServer.start();
client.fromClient.println("setNickname:"+menuWindow.nickNameTextFieldHostMenu.getText());
break;
} catch (IOException e) {}
}
});
menuWindow.backToMainMenuButton.addActionListener(back -> {
menuWindow.mainMenu.setVisible(true);
menuWindow.menuPlay.setVisible(false);
});
menuWindow.backFromJoinMenuButton.addActionListener(back -> {
if(player.playerConnected){
try{
client.fromClient.println("Quit");
player.PlayerDisconnect();
}catch (NullPointerException error) {
}
}else{
menuWindow.menuPlay.setVisible(true);
menuWindow.menuJoinGame.setVisible(false);
}
});
menuWindow.backFromHostMenuButton.addActionListener(back -> {
synchronized (this) {
stopHostingGame=true;
try {
Thread.sleep(1000);
server.serverSocketChannel.close();
client.fromClient.println("Quit");
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
});
menuWindow.changeNickNameHostButton.addActionListener(back -> {
client.fromClient.println("changeNickname:"+menuWindow.nickNameTextFieldHostMenu.getText());
});
menuWindow.changeNickNameJoinButton.addActionListener(back -> {
client.fromClient.println("changeNickname:"+menuWindow.nickNameTextFieldJoinMenu.getText());
});
menuWindow.startGameButton.addActionListener(back -> {
GamingWindow a=new GamingWindow();
/*synchronized (this) {
gameStarted=true;
}*/
});
menuWindow.leaveButton.addActionListener(leaveGame -> System.exit(0));
window = new JFrame();
window.setTitle("PoliPoly");
window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
window.setSize(800, 600);
window.setLocationRelativeTo(null);
window.add(container);
}
public void show() {
window.setVisible(true);
}
}
| // Tworzenie panelu Container | import javax.swing.*;
import java.awt.*;
import java.io.IOException;
import java.net.Socket;
public class MainWindow {
private final JFrame window;
private static final int BUTTONFONTSIZE = 16;
private Server server;
private Client client;
boolean gameStarted;
boolean stopHostingGame;
private final NickNameTakenWindow alertWindow;
public MainWindow(){
gameStarted=false;
stopHostingGame=false;
MenuWindow menuWindow=new MenuWindow();
alertWindow=new NickNameTakenWindow();
Player player=new Player();
JPanel container;
// Tworzenie panelu <SUF>
container = new JPanel() {
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
ImageIcon menuBackground = new ImageIcon("assets/tmp_bg.png");
g.drawImage(menuBackground.getImage(), 0, 0, null);
}
};
container.setLayout(new BoxLayout(container, BoxLayout.Y_AXIS));
menuWindow.logoLabel.setBorder(BorderFactory.createEmptyBorder(60, 0, 0, 0));
container.add(menuWindow.logoLabel);
container.add(menuWindow.mainMenu);
container.add(menuWindow.menuHostGame, BorderLayout.NORTH);
container.add(menuWindow.menuJoinGame);
menuWindow.menuPlay.setVisible(false);
menuWindow.menuHostGame.setVisible(false);
menuWindow.menuJoinGame.setVisible(false);
container.add(menuWindow.menuPlay);
//akcje przycisków
menuWindow.playButton.addActionListener(back -> {
menuWindow.mainMenu.setVisible(false);
menuWindow.menuPlay.setVisible(true);
});
menuWindow.enterJoinMenuButton.addActionListener(back -> {
menuWindow.menuPlay.setVisible(false);
menuWindow.menuJoinGame.setVisible(true);
});
menuWindow.joinGameButton.addActionListener(back -> {
if(!player.playerConnected){
try {
client=new Client();
client.ClientConnect(menuWindow.ipAddressGetTextField.getText(),8080);
client.SetCommunicationParameters(client.clientSocket);
player.PlayerConnect();
ClientReadFromServer clientReadFromServer=new ClientReadFromServer(client,menuWindow,menuWindow.joinGameListButtons,alertWindow,player);
clientReadFromServer.start();
client.fromClient.println("setNickname:"+menuWindow.nickNameTextFieldJoinMenu.getText());
} catch (IOException e) {
}
}else{
alertWindow.setMessage("Jesteś juz w lobby!!");
alertWindow.show();
}
});
menuWindow.enterHostMenuButton.addActionListener(back -> {
server=new Server();
synchronized (this) {
stopHostingGame=false;
}
try {
server.openSocket(8080);
server.serverSocketChannel.setSoTimeout(1000);
} catch (IOException e) {
alertWindow.setMessage("Server juz istnieje!");
alertWindow.show();
return;
}
menuWindow.menuPlay.setVisible(false);
menuWindow.menuHostGame.setVisible(true);
Thread ThreadWaitingForPlayers = new Thread(() -> {
ServerMainThread serverMainThread=new ServerMainThread(server);
serverMainThread.start();
while (true){
synchronized (this) {
if(gameStarted || stopHostingGame){
break;
}
}
Socket tmp_clientSock = null;
try {
tmp_clientSock = server.serverSocketChannel.accept();
server.addSemaphore();
Communication tmp_Comm=server.listOfCommunication.get(server.listOfCommunication.size()-1);
ServerReadFromClient serverReadThread=new ServerReadFromClient(tmp_clientSock,tmp_Comm,server.syncJoiningPlayers);
serverReadThread.start();
ServerWriteTOClient serverWriteThread=new ServerWriteTOClient(tmp_clientSock,tmp_Comm);
serverWriteThread.start();
} catch (IOException e) {}
}
});
ThreadWaitingForPlayers.start();
while (true){
try {
client=new Client();
client.ClientConnect("localhost",8080);
client.SetCommunicationParameters(client.clientSocket);
ClientReadFromServer clientReadFromServer=new ClientReadFromServer(client,menuWindow,menuWindow.hostGameListButtons,alertWindow,player);
clientReadFromServer.start();
client.fromClient.println("setNickname:"+menuWindow.nickNameTextFieldHostMenu.getText());
break;
} catch (IOException e) {}
}
});
menuWindow.backToMainMenuButton.addActionListener(back -> {
menuWindow.mainMenu.setVisible(true);
menuWindow.menuPlay.setVisible(false);
});
menuWindow.backFromJoinMenuButton.addActionListener(back -> {
if(player.playerConnected){
try{
client.fromClient.println("Quit");
player.PlayerDisconnect();
}catch (NullPointerException error) {
}
}else{
menuWindow.menuPlay.setVisible(true);
menuWindow.menuJoinGame.setVisible(false);
}
});
menuWindow.backFromHostMenuButton.addActionListener(back -> {
synchronized (this) {
stopHostingGame=true;
try {
Thread.sleep(1000);
server.serverSocketChannel.close();
client.fromClient.println("Quit");
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
});
menuWindow.changeNickNameHostButton.addActionListener(back -> {
client.fromClient.println("changeNickname:"+menuWindow.nickNameTextFieldHostMenu.getText());
});
menuWindow.changeNickNameJoinButton.addActionListener(back -> {
client.fromClient.println("changeNickname:"+menuWindow.nickNameTextFieldJoinMenu.getText());
});
menuWindow.startGameButton.addActionListener(back -> {
GamingWindow a=new GamingWindow();
/*synchronized (this) {
gameStarted=true;
}*/
});
menuWindow.leaveButton.addActionListener(leaveGame -> System.exit(0));
window = new JFrame();
window.setTitle("PoliPoly");
window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
window.setSize(800, 600);
window.setLocationRelativeTo(null);
window.add(container);
}
public void show() {
window.setVisible(true);
}
}
| t |
10562_2 | JustFiesta/JavaBasics | 566 | src/FirstYear/Labs/no4/Person.java | package FirstYear.Labs.no4;
public class Person {
//Definicja pól
String imie, nazwisko;
int wiek;
//metody dla tej klasy
public void wypisz() {
System.out.println("Imie i nazwisko: "+imie+" "+nazwisko+" i wiek: "+wiek);
}
//Konstruktory - zawsze są publiczne, mają nazwę klasy, tworzy obiekt i wpisuje od razu dane
//Niejawny konstruktor
public Person(){
}
//Przeciażenie (overload) metody - zmiana ciała metody
//this - wskazuje na obiekt klasy
public Person(String imie){
this.imie = imie; //do pola klasy wstaw to co jest w metodzie
}
// alt+insert - generator np konstruktorów
//
// public Person(int wiek) {
// this.wiek = wiek;
// }
public Person(String imie, String nazwisko, int wiek) {
this.imie = imie;
this.nazwisko = nazwisko;
this.wiek = wiek;
}
//Gettery i settery - umożliwiają pobranie i ustawienie pola w klasie
public String getImie() {
return imie;
}
public String getNazwisko() {
return nazwisko;
}
public int getWiek() {
return wiek;
}
public void setImie(String imie) {
this.imie = imie;
}
public void setNazwisko(String nazwisko) {
this.nazwisko = nazwisko;
}
public void setWiek(int wiek) {
this.wiek = wiek;
}
@Override
public String toString() {
return "Person{" +
"imie='" + imie + '\'' +
", nazwisko='" + nazwisko + '\'' +
", wiek=" + wiek +
'}';
}
}
| //Przeciażenie (overload) metody - zmiana ciała metody | package FirstYear.Labs.no4;
public class Person {
//Definicja pól
String imie, nazwisko;
int wiek;
//metody dla tej klasy
public void wypisz() {
System.out.println("Imie i nazwisko: "+imie+" "+nazwisko+" i wiek: "+wiek);
}
//Konstruktory - zawsze są publiczne, mają nazwę klasy, tworzy obiekt i wpisuje od razu dane
//Niejawny konstruktor
public Person(){
}
//Przeciażenie (overload) <SUF>
//this - wskazuje na obiekt klasy
public Person(String imie){
this.imie = imie; //do pola klasy wstaw to co jest w metodzie
}
// alt+insert - generator np konstruktorów
//
// public Person(int wiek) {
// this.wiek = wiek;
// }
public Person(String imie, String nazwisko, int wiek) {
this.imie = imie;
this.nazwisko = nazwisko;
this.wiek = wiek;
}
//Gettery i settery - umożliwiają pobranie i ustawienie pola w klasie
public String getImie() {
return imie;
}
public String getNazwisko() {
return nazwisko;
}
public int getWiek() {
return wiek;
}
public void setImie(String imie) {
this.imie = imie;
}
public void setNazwisko(String nazwisko) {
this.nazwisko = nazwisko;
}
public void setWiek(int wiek) {
this.wiek = wiek;
}
@Override
public String toString() {
return "Person{" +
"imie='" + imie + '\'' +
", nazwisko='" + nazwisko + '\'' +
", wiek=" + wiek +
'}';
}
}
| t |
3629_0 | KNJPJATK/2017_Wtorek_Open | 1,487 | Zajecia1/Main.java | package main;
public class Main {
public static void main(String[] args) {
// Komentarz jednolinijkowy
/*
* Komentarz
* Wielolinijkowy
*
*/
// Proste wypisanie
System.out.println("Hello World");
// Typy proste zmiennych
// Deklaracje
int i;
char c;
double d;
float f;
boolean b;
byte a;
// Inicjalizacje
i = 10;
c = 'a'; // char jest również typem liczbowym! - możemy do niego dodawać i odejmować np int
c = 15;
d = 2.5;
f = 2.5f;
b = true;
a = 100;
// wypisywanie zmiennych - odwołujemy się po nadanej im nazwie
System.out.println(i);
// modulo - reszta z dzielenia
System.out.println(13 % 2);
int z;
double y;
// Prosty prosty program dodawjący
/*
System.out.println("Wprowadz pierwsza liczbe: ");
Scanner scanner = new Scanner(System.in);
z = scanner.nextInt();
System.out.println("Wprowadz druga liczbe: ");
y = scanner.nextDouble();
int wynik = (int) (z + y);
double wynikD = z + y;
*/
// int wynik2 = Integer.parseInt(wynikD);
// TABLICE
// int tablica2[];
// Dwa sposoby tworzenia tablic
int[] tablica1 = new int[10];
int[] tablica3 = {1, 2, 3, 4, 5, 6};
// Przypisywanie wartości w tablicy
tablica1[0] = 5; // tablice zaczynamy od indeksu 0! Ostatni znajduje się na length-1
tablica1[1] = 10;
System.out.println(tablica1[0]);
// PĘTLE
// for z użyciem wartości długości tablicy
for (int x = 0; x < tablica3.length; x++) {
System.out.println(tablica3[x]);
}
System.out.println("==============================================");
// foreach - wypisujemy każdy element
for (int element : tablica3) {
System.out.println(element);
}
System.out.println("==============================================");
// While - potrzebna wartośc do zliczania iteracji, niewygodne przy wypisywaniu elementów
int rozmiar = 0;
while (rozmiar < tablica3.length) {
System.out.println(tablica3[rozmiar]);
rozmiar++;
}
// Do While - zawsze wykonamy przynajmniej jeden "obrót" pętli.
int rozmiar2 = 0;
do {
System.out.println(tablica3[rozmiar2]);
rozmiar2++;
} while (rozmiar2 < tablica3.length);
// Instrukcje warunkowe
int warunek = 10;
// if sprawdzamy zawsze
if (warunek == 10) {
System.out.println("Zgadza sie");
} else if (warunek == 5) {
// else if sprawdzamy tylko jeśli nie spełnione są wcześniejsze warunki if/else if
System.out.println("Nie zgadza sie");
} else {
// else wykonywane jest tylko jeśli nie spełniony jest żadny warunek if/else if
System.out.println("Tez blad");
}
System.out.println("==============Switch=========================");
int wybor = 10;
// Jeśli nie mamy breaków wykonujemy wszystkie linijki kodu poniżej danego break'a.
switch (wybor) {
case 5:
System.out.println(5);
break;
case 10:
System.out.println(10);
break;
case 15:
System.out.println(15);
break;
default:
System.out.println("nic");
}
// operator trynarny, działa jak if
// to so samo co:
String wyraz;
wyraz = (5 > 1) ? "tak" : "nie";
System.out.println(wyraz);
// zapis tego samego za pomocą ifa
String wyraz;
if (5 > 1) {
wyraz = "tak";
} else {
wyraz = "nie";
}
}
}
| /*
* Komentarz
* Wielolinijkowy
*
*/ | package main;
public class Main {
public static void main(String[] args) {
// Komentarz jednolinijkowy
/*
* Komentarz
<SUF>*/
// Proste wypisanie
System.out.println("Hello World");
// Typy proste zmiennych
// Deklaracje
int i;
char c;
double d;
float f;
boolean b;
byte a;
// Inicjalizacje
i = 10;
c = 'a'; // char jest również typem liczbowym! - możemy do niego dodawać i odejmować np int
c = 15;
d = 2.5;
f = 2.5f;
b = true;
a = 100;
// wypisywanie zmiennych - odwołujemy się po nadanej im nazwie
System.out.println(i);
// modulo - reszta z dzielenia
System.out.println(13 % 2);
int z;
double y;
// Prosty prosty program dodawjący
/*
System.out.println("Wprowadz pierwsza liczbe: ");
Scanner scanner = new Scanner(System.in);
z = scanner.nextInt();
System.out.println("Wprowadz druga liczbe: ");
y = scanner.nextDouble();
int wynik = (int) (z + y);
double wynikD = z + y;
*/
// int wynik2 = Integer.parseInt(wynikD);
// TABLICE
// int tablica2[];
// Dwa sposoby tworzenia tablic
int[] tablica1 = new int[10];
int[] tablica3 = {1, 2, 3, 4, 5, 6};
// Przypisywanie wartości w tablicy
tablica1[0] = 5; // tablice zaczynamy od indeksu 0! Ostatni znajduje się na length-1
tablica1[1] = 10;
System.out.println(tablica1[0]);
// PĘTLE
// for z użyciem wartości długości tablicy
for (int x = 0; x < tablica3.length; x++) {
System.out.println(tablica3[x]);
}
System.out.println("==============================================");
// foreach - wypisujemy każdy element
for (int element : tablica3) {
System.out.println(element);
}
System.out.println("==============================================");
// While - potrzebna wartośc do zliczania iteracji, niewygodne przy wypisywaniu elementów
int rozmiar = 0;
while (rozmiar < tablica3.length) {
System.out.println(tablica3[rozmiar]);
rozmiar++;
}
// Do While - zawsze wykonamy przynajmniej jeden "obrót" pętli.
int rozmiar2 = 0;
do {
System.out.println(tablica3[rozmiar2]);
rozmiar2++;
} while (rozmiar2 < tablica3.length);
// Instrukcje warunkowe
int warunek = 10;
// if sprawdzamy zawsze
if (warunek == 10) {
System.out.println("Zgadza sie");
} else if (warunek == 5) {
// else if sprawdzamy tylko jeśli nie spełnione są wcześniejsze warunki if/else if
System.out.println("Nie zgadza sie");
} else {
// else wykonywane jest tylko jeśli nie spełniony jest żadny warunek if/else if
System.out.println("Tez blad");
}
System.out.println("==============Switch=========================");
int wybor = 10;
// Jeśli nie mamy breaków wykonujemy wszystkie linijki kodu poniżej danego break'a.
switch (wybor) {
case 5:
System.out.println(5);
break;
case 10:
System.out.println(10);
break;
case 15:
System.out.println(15);
break;
default:
System.out.println("nic");
}
// operator trynarny, działa jak if
// to so samo co:
String wyraz;
wyraz = (5 > 1) ? "tak" : "nie";
System.out.println(wyraz);
// zapis tego samego za pomocą ifa
String wyraz;
if (5 > 1) {
wyraz = "tak";
} else {
wyraz = "nie";
}
}
}
| t |
5235_1 | Kalwador/Java-2D-Game | 1,897 | LegendaryAdventure/src/states/QuestsState.java | package states;
import gameUtils.Fonts;
import org.newdawn.slick.Color;
import java.util.ArrayList;
import org.lwjgl.input.Mouse;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.Input;
import org.newdawn.slick.MouseListener;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.state.BasicGameState;
import org.newdawn.slick.state.StateBasedGame;
public class QuestsState extends BasicGameState {
String mouse;
String onScreenLoc;
gameUtils.Fonts fonts;
ArrayList<String> questy = new ArrayList<>();
int bp = 0;
Color c = Color.black;
String actualScr;
//wsp pocz suwaka
int suwX = 790;
int suwY = 174;
@Override
public void init(GameContainer gc, StateBasedGame sbg) throws SlickException {
mouse = ""; onScreenLoc = " ";
//Wytworzenie własnej czcionki
fonts = new gameUtils.Fonts();
questy.add("Zemsta na bandytach");
questy.add("Gdzie uciekl herszt");
questy.add("Obozowisko na polach");
questy.add("Wyprawa po futra.");
questy.add("Polowanie na lisy");
questy.add("Zaginiony ładunek");
questy.add("Pradawna krypa");
questy.add("Smocze ostrze");
questy.add("Gdzie są bandyci");
questy.add("Oboz troli");
questy.add("Zaginiona paczka");
questy.add("Bezdomny pies");
questy.add("Rybobranie");
}
@Override
public void update(GameContainer gc, StateBasedGame sbg, int i) throws SlickException {
Input input = gc.getInput();
int xpos = Mouse.getX();
int ypos = Mouse.getY();
int scrolling = Mouse.getDWheel();
mouse = "x= " + xpos + " y=" + ypos;
onScreenLoc = "x= " + xpos + " y=" + Math.abs(720-ypos);
if (input.isKeyPressed(Input.KEY_ESCAPE) || input.isKeyPressed(Input.KEY_M)) {
sbg.enterState(1);
}
//powrót do menu
if (((xpos > 520 && xpos < 720) && (ypos > 145 && ypos < 175))
|| /* X okna*/((xpos > 779 && xpos < 812) && (ypos > 606 && ypos < 636))) {
if (input.isMouseButtonDown(0)) {
sbg.enterState(1);
}
}
//wyjście
// if ((xpos > 470 && xpos < 630) && (ypos > 280 && ypos < 312)) {
// if (input.isMouseButtonDown(0)) {
// System.exit(0);
// }
// }
//Przewijanie do góry - scrool myszy, klawisz, przycisk góra
if ((scrolling > 0) || input.isKeyPressed(Input.KEY_UP) || ((xpos > 788 && xpos < 814) && (ypos > 546 && ypos < 569) && (input.isMousePressed(0)))) {
if (bp > 0) {
bp--;
suwY -= 24;
}
}
//Przewijanie do dołu - scrool myszy, klawisz, przycisk dół
if ((scrolling < 0) || input.isKeyPressed(Input.KEY_DOWN) || ((xpos > 788 && xpos < 814) && (ypos > 97 && ypos < 124) && (input.isMousePressed(0)))) {
if (bp < (questy.size() - 11)) {
bp++;
suwY += 24;
}
}
}
@Override
public void render(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
//Tło sceny - rozmyty printscreen
actualScr = screenBlur.ScreenClass.screenNumber();
Image skrinGB = new Image(actualScr);
g.drawImage(skrinGB, 0, 0);
//Okno questa
Image menuW = new Image("graphic/menu/QuestNew.png");
g.drawImage(menuW, 0, 0);
//Suwaczek
Image skrolus = new Image("graphic/menu/skrolus.png");
g.drawImage(skrolus, suwX, suwY);
Fonts.print18().drawString(100, 30, onScreenLoc);
Fonts.print18().drawString(100, 10, mouse);
Fonts.print18().drawString(100, 30, " bieżący indeks " + String.valueOf(bp));
Fonts.print18().drawString(100, 50, " rozmiar listy " + String.valueOf(questy.size()));
// g.drawString("Opcje", 520, 375);
// g.drawRoundRect(520, 375, 300, 60, 6);
// g.drawString("Twórcy", 520, 445);
// g.drawRoundRect(520, 445, 300, 60, 6);
// g.drawString("Wyjście", 520, 515);
// g.drawRoundRect(520, 515, 300, 60, 6);
Fonts.print18().drawString(600, 100, "Questy");// (przewijanie strzalkami)");
int wspqy = 175; // wsp pocz y wyświetlania listy
for (int i = bp; i < bp + 11; i++) {
Fonts.print18().drawString(519, wspqy += 30, questy.get(i), c);
}
Fonts.print18().drawString(530, 555, "Powrót do gry", c);
g.drawRoundRect(520, 545, 200, 30, 6);
Fonts.print18().drawString(510, 595, "C O N C E P T Q U E S T S", c);
}
public QuestsState(int state) {
}
public QuestsState() {
}
public int getID() {
return 5;
}
}
| //Wytworzenie własnej czcionki | package states;
import gameUtils.Fonts;
import org.newdawn.slick.Color;
import java.util.ArrayList;
import org.lwjgl.input.Mouse;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.Input;
import org.newdawn.slick.MouseListener;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.state.BasicGameState;
import org.newdawn.slick.state.StateBasedGame;
public class QuestsState extends BasicGameState {
String mouse;
String onScreenLoc;
gameUtils.Fonts fonts;
ArrayList<String> questy = new ArrayList<>();
int bp = 0;
Color c = Color.black;
String actualScr;
//wsp pocz suwaka
int suwX = 790;
int suwY = 174;
@Override
public void init(GameContainer gc, StateBasedGame sbg) throws SlickException {
mouse = ""; onScreenLoc = " ";
//Wytworzenie własnej <SUF>
fonts = new gameUtils.Fonts();
questy.add("Zemsta na bandytach");
questy.add("Gdzie uciekl herszt");
questy.add("Obozowisko na polach");
questy.add("Wyprawa po futra.");
questy.add("Polowanie na lisy");
questy.add("Zaginiony ładunek");
questy.add("Pradawna krypa");
questy.add("Smocze ostrze");
questy.add("Gdzie są bandyci");
questy.add("Oboz troli");
questy.add("Zaginiona paczka");
questy.add("Bezdomny pies");
questy.add("Rybobranie");
}
@Override
public void update(GameContainer gc, StateBasedGame sbg, int i) throws SlickException {
Input input = gc.getInput();
int xpos = Mouse.getX();
int ypos = Mouse.getY();
int scrolling = Mouse.getDWheel();
mouse = "x= " + xpos + " y=" + ypos;
onScreenLoc = "x= " + xpos + " y=" + Math.abs(720-ypos);
if (input.isKeyPressed(Input.KEY_ESCAPE) || input.isKeyPressed(Input.KEY_M)) {
sbg.enterState(1);
}
//powrót do menu
if (((xpos > 520 && xpos < 720) && (ypos > 145 && ypos < 175))
|| /* X okna*/((xpos > 779 && xpos < 812) && (ypos > 606 && ypos < 636))) {
if (input.isMouseButtonDown(0)) {
sbg.enterState(1);
}
}
//wyjście
// if ((xpos > 470 && xpos < 630) && (ypos > 280 && ypos < 312)) {
// if (input.isMouseButtonDown(0)) {
// System.exit(0);
// }
// }
//Przewijanie do góry - scrool myszy, klawisz, przycisk góra
if ((scrolling > 0) || input.isKeyPressed(Input.KEY_UP) || ((xpos > 788 && xpos < 814) && (ypos > 546 && ypos < 569) && (input.isMousePressed(0)))) {
if (bp > 0) {
bp--;
suwY -= 24;
}
}
//Przewijanie do dołu - scrool myszy, klawisz, przycisk dół
if ((scrolling < 0) || input.isKeyPressed(Input.KEY_DOWN) || ((xpos > 788 && xpos < 814) && (ypos > 97 && ypos < 124) && (input.isMousePressed(0)))) {
if (bp < (questy.size() - 11)) {
bp++;
suwY += 24;
}
}
}
@Override
public void render(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
//Tło sceny - rozmyty printscreen
actualScr = screenBlur.ScreenClass.screenNumber();
Image skrinGB = new Image(actualScr);
g.drawImage(skrinGB, 0, 0);
//Okno questa
Image menuW = new Image("graphic/menu/QuestNew.png");
g.drawImage(menuW, 0, 0);
//Suwaczek
Image skrolus = new Image("graphic/menu/skrolus.png");
g.drawImage(skrolus, suwX, suwY);
Fonts.print18().drawString(100, 30, onScreenLoc);
Fonts.print18().drawString(100, 10, mouse);
Fonts.print18().drawString(100, 30, " bieżący indeks " + String.valueOf(bp));
Fonts.print18().drawString(100, 50, " rozmiar listy " + String.valueOf(questy.size()));
// g.drawString("Opcje", 520, 375);
// g.drawRoundRect(520, 375, 300, 60, 6);
// g.drawString("Twórcy", 520, 445);
// g.drawRoundRect(520, 445, 300, 60, 6);
// g.drawString("Wyjście", 520, 515);
// g.drawRoundRect(520, 515, 300, 60, 6);
Fonts.print18().drawString(600, 100, "Questy");// (przewijanie strzalkami)");
int wspqy = 175; // wsp pocz y wyświetlania listy
for (int i = bp; i < bp + 11; i++) {
Fonts.print18().drawString(519, wspqy += 30, questy.get(i), c);
}
Fonts.print18().drawString(530, 555, "Powrót do gry", c);
g.drawRoundRect(520, 545, 200, 30, 6);
Fonts.print18().drawString(510, 595, "C O N C E P T Q U E S T S", c);
}
public QuestsState(int state) {
}
public QuestsState() {
}
public int getID() {
return 5;
}
}
| t |
9959_0 | KamilMatejuk/University | 783 | Java/Binary_Search_Tree/BinarySearchTree.java | /* Kamil Matejuk */
import java.io.Serializable;
public class BinarySearchTree<T> implements Serializable {
TreeNode root;
/**
* zerowanie aktualnego drzewa
*/
public BinarySearchTree(){
root = null;
}
/**
* Wstawienie do drzewa nowego węzła o wartości value
* @param value
*/
public void insertTreeNode(T value) {
if (value != null) {
TreeNode node = new TreeNode(value);
if (root == null) {
root = node;
System.out.println("Element \"" + value + "\" was added succesfully");
} else {
TreeNode nd = root;
TreeNode parent;
while (true) {
parent = nd;
if(node.compareTo(nd.value)>0){
nd = nd.rightChild;
if (nd == null) {
parent.setRightChild(node);
System.out.println("Element \"" + value + "\" was added succesfully");
return;
}
} else {
nd = nd.leftChild;
if (nd == null) {
parent.setLeftChild(node);
System.out.println("Element \"" + value + "\" was added succesfully");
return;
}
}
}
}
}
}
/**
* usunęcie węzła o wartości value
* @param value
* @return prawda gdy usunięto, fałsz gdy nie
*/
public boolean deleteTreeNode(T value) {
//TODO nie działa, cały czas zwraca false
//http://www.algolist.net/Data_structures/Binary_search_tree/Removal
if (root == null || value == null) {
return false;
} else {
if (root.value.equals(value)){
TreeNode auxRoot = new TreeNode(0);
auxRoot.setLeftChild(root);
boolean result = root.remove(value, auxRoot);
root = auxRoot.leftChild;
return result;
} else {
return root.remove(value, null);
}
}
}
/**
* wyszukanie rekurencyjnie węzła o warośi value
* @param node wezeł który rozpatrujemy
* @param value wartość której szukamy
* @return prawda gdy znaleziono, fałsz gdy nie
*/
public boolean searchTreeNode(TreeNode node, T value){
if(node == null || value == null){
return false;
} else if(node.value.equals(value)){
return true;
} else if(node.compareTo(value)<0){
return searchTreeNode(node.rightChild, value);
} else {
return searchTreeNode(node.leftChild, value);
}
}
}
| /**
* zerowanie aktualnego drzewa
*/ | /* Kamil Matejuk */
import java.io.Serializable;
public class BinarySearchTree<T> implements Serializable {
TreeNode root;
/**
* zerowanie aktualnego drzewa <SUF>*/
public BinarySearchTree(){
root = null;
}
/**
* Wstawienie do drzewa nowego węzła o wartości value
* @param value
*/
public void insertTreeNode(T value) {
if (value != null) {
TreeNode node = new TreeNode(value);
if (root == null) {
root = node;
System.out.println("Element \"" + value + "\" was added succesfully");
} else {
TreeNode nd = root;
TreeNode parent;
while (true) {
parent = nd;
if(node.compareTo(nd.value)>0){
nd = nd.rightChild;
if (nd == null) {
parent.setRightChild(node);
System.out.println("Element \"" + value + "\" was added succesfully");
return;
}
} else {
nd = nd.leftChild;
if (nd == null) {
parent.setLeftChild(node);
System.out.println("Element \"" + value + "\" was added succesfully");
return;
}
}
}
}
}
}
/**
* usunęcie węzła o wartości value
* @param value
* @return prawda gdy usunięto, fałsz gdy nie
*/
public boolean deleteTreeNode(T value) {
//TODO nie działa, cały czas zwraca false
//http://www.algolist.net/Data_structures/Binary_search_tree/Removal
if (root == null || value == null) {
return false;
} else {
if (root.value.equals(value)){
TreeNode auxRoot = new TreeNode(0);
auxRoot.setLeftChild(root);
boolean result = root.remove(value, auxRoot);
root = auxRoot.leftChild;
return result;
} else {
return root.remove(value, null);
}
}
}
/**
* wyszukanie rekurencyjnie węzła o warośi value
* @param node wezeł który rozpatrujemy
* @param value wartość której szukamy
* @return prawda gdy znaleziono, fałsz gdy nie
*/
public boolean searchTreeNode(TreeNode node, T value){
if(node == null || value == null){
return false;
} else if(node.value.equals(value)){
return true;
} else if(node.compareTo(value)<0){
return searchTreeNode(node.rightChild, value);
} else {
return searchTreeNode(node.leftChild, value);
}
}
}
| t |
5157_0 | Kamila-Kapinos/pp3 | 437 | 02-ClassesAndObjects/classes_and_objects/Student.java | public class Student{
//atrybuty:
String name;
int age;
String ID;
boolean isValid;
int semesterNum;
double avgGrade;
//metody:
public void sayHello(){
System.out.println("Hello!");
}
public void displayName(){
System.out.println("I'm "+ this.name);
}
public void displayStudentData(){
System.out.println("I'm "+ this.name + "\nSemester "+ this.semesterNum + "\nAvg grade "+ this.avgGrade);
}
public void displayAge(){
System.out.println("I'm "+ this.age + " years old");
}
public void changeIDStatus(){
this.isValid = !isValid;
}
public void displayStudentStatus(){
System.out.println("My name is " + this.name + "my ID " + this.ID + "is " + this.isValid);
}
//w momencie uruchomienia programu mogę przekazać dane
public static void main(String[] args){
Student s1 = new Student(); //konstruktor sam się zrobił
s1.name = "Ola";
s1.age = 20;
s1.ID = "s123234";
s1.isValid = true;
s1.semesterNum = 2;
s1.avgGrade = 3.5;
s1.sayHello();
s1.displayStudentData();
s1.changeIDStatus();
s1.displayStudentStatus();
}
} | //w momencie uruchomienia programu mogę przekazać dane | public class Student{
//atrybuty:
String name;
int age;
String ID;
boolean isValid;
int semesterNum;
double avgGrade;
//metody:
public void sayHello(){
System.out.println("Hello!");
}
public void displayName(){
System.out.println("I'm "+ this.name);
}
public void displayStudentData(){
System.out.println("I'm "+ this.name + "\nSemester "+ this.semesterNum + "\nAvg grade "+ this.avgGrade);
}
public void displayAge(){
System.out.println("I'm "+ this.age + " years old");
}
public void changeIDStatus(){
this.isValid = !isValid;
}
public void displayStudentStatus(){
System.out.println("My name is " + this.name + "my ID " + this.ID + "is " + this.isValid);
}
//w momencie <SUF>
public static void main(String[] args){
Student s1 = new Student(); //konstruktor sam się zrobił
s1.name = "Ola";
s1.age = 20;
s1.ID = "s123234";
s1.isValid = true;
s1.semesterNum = 2;
s1.avgGrade = 3.5;
s1.sayHello();
s1.displayStudentData();
s1.changeIDStatus();
s1.displayStudentStatus();
}
} | t |
6164_1 | Kamotek/pwr-computer-science-courses | 854 | Semester2/Operation systems/SO3/SO3/src/App.java | public class App {
public static void main(String[] args) throws Exception {
//pagingManager parameters
int RAM_CAPACITY = 50;
int VIRTUAL_MEMORY_CAPACITY = 500;
// int ALGORITHM = 1;
//procesQueue parameters
int QUEUE_SIZE = 2000;
//proces parameters
int PROCES_SIZE = 5;
int PROCES_OFFSET = 5;
ProcessesQueue queue1 = new ProcessesQueue(QUEUE_SIZE, VIRTUAL_MEMORY_CAPACITY, PROCES_SIZE, PROCES_OFFSET);
ProcessesQueue queue2 = new ProcessesQueue(queue1);
ProcessesQueue queue3 = new ProcessesQueue(queue1);
ProcessesQueue queue4 = new ProcessesQueue(queue1);
ProcessesQueue queue5 = new ProcessesQueue(queue1);
PagingManager randomManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 1, queue1.processArray);
PagingManager fifoManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 2, queue2.processArray);
PagingManager optManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 3, queue3.processArray);
PagingManager lruManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 4, queue4.processArray);
PagingManager alruManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 5, queue5.processArray);
}
}
// Main - klasa służąca do wywołania całej symulacji i określenia jej parametrów
// Proces - obiekt zawierający w sobie tablicę liczb, będących referencjami do konkretnych obszarów w pamięci
// * Lokalność odwolan - będziemy prawdopodobnie brali po kilka sąsiadujących ramek czy coś takiego
// RAM - obiekt symulujący pamięć ram, będzie miał w sobie tablicę o sztywno określonej pojemności i indeksach, którym będziemy przypisywać, bądź odpisywać numery indeksów bloków w pamięci
// VirtualMemory - również obiekt mający w sobie tablicę, większą niż ta w RAM, w której od początku będziemy mieli sztywno wygenerowane dane indeksowane po kolei
// ReferenceManager, czyli obiekt posiadający tablicę par liczb, gdzie po otrzymaniu żądań będzie parował miejsca w Ramie z danymi w VirtualMemory, bądź też rozkazywał RAMowi zwolnić sloty zgodnie z algorytmami
// Klasy algorytmów, których parametrami będzie oczywiście nasz menadżer
// RAM - potrzebujemy znac kolejnosc zaladowania stron, znac ilosc wywolan indywidualnej strony | // Main - klasa służąca do wywołania całej symulacji i określenia jej parametrów | public class App {
public static void main(String[] args) throws Exception {
//pagingManager parameters
int RAM_CAPACITY = 50;
int VIRTUAL_MEMORY_CAPACITY = 500;
// int ALGORITHM = 1;
//procesQueue parameters
int QUEUE_SIZE = 2000;
//proces parameters
int PROCES_SIZE = 5;
int PROCES_OFFSET = 5;
ProcessesQueue queue1 = new ProcessesQueue(QUEUE_SIZE, VIRTUAL_MEMORY_CAPACITY, PROCES_SIZE, PROCES_OFFSET);
ProcessesQueue queue2 = new ProcessesQueue(queue1);
ProcessesQueue queue3 = new ProcessesQueue(queue1);
ProcessesQueue queue4 = new ProcessesQueue(queue1);
ProcessesQueue queue5 = new ProcessesQueue(queue1);
PagingManager randomManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 1, queue1.processArray);
PagingManager fifoManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 2, queue2.processArray);
PagingManager optManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 3, queue3.processArray);
PagingManager lruManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 4, queue4.processArray);
PagingManager alruManager = new PagingManager(RAM_CAPACITY, VIRTUAL_MEMORY_CAPACITY, 5, queue5.processArray);
}
}
// Main - <SUF>
// Proces - obiekt zawierający w sobie tablicę liczb, będących referencjami do konkretnych obszarów w pamięci
// * Lokalność odwolan - będziemy prawdopodobnie brali po kilka sąsiadujących ramek czy coś takiego
// RAM - obiekt symulujący pamięć ram, będzie miał w sobie tablicę o sztywno określonej pojemności i indeksach, którym będziemy przypisywać, bądź odpisywać numery indeksów bloków w pamięci
// VirtualMemory - również obiekt mający w sobie tablicę, większą niż ta w RAM, w której od początku będziemy mieli sztywno wygenerowane dane indeksowane po kolei
// ReferenceManager, czyli obiekt posiadający tablicę par liczb, gdzie po otrzymaniu żądań będzie parował miejsca w Ramie z danymi w VirtualMemory, bądź też rozkazywał RAMowi zwolnić sloty zgodnie z algorytmami
// Klasy algorytmów, których parametrami będzie oczywiście nasz menadżer
// RAM - potrzebujemy znac kolejnosc zaladowania stron, znac ilosc wywolan indywidualnej strony | t |
3496_1 | Kawyn/studia | 497 | kurs programowania/lista 5/Manual.java | import javafx.scene.control.Alert;
/**
* <b>Alert</b> zawierający instrukcje obsługi.
*/
public class Manual extends Alert {
public Manual() {
super(AlertType.INFORMATION);
this.setGraphic(null); // usuwa ikonkę "i" z nagłówka
this.setTitle("Instrukcja");
this.setHeaderText("Instrukcja");
this.setContentText(
"Aby zrobić figurę, trzeba wybrać jakąś z menu i przeciągnąć po tym białym. Tak jak w Ms Paint.\n\n" +
"Aby oznaczyć figurę jako aktywną, trzeba ją kliknąć lewym przyciskiem myszy.\n\n" +
"Aby przesunąć figurę trzeba ją oznaczyć jako aktywną, następnie złapać i przeciągnąć.\n\n" +
"Aby zmnienić rozmiar figury trzeba ją oznaczyć jako aktywną, najechać na nią myszką i pokręcić kółkiem.\n\n"
+
"Aby obrócić figurę trzeba ją oznaczyć jako aktywną, i przytrzymać Q lub E.\n\n" +
"Aby zmienić kolor figury trzeba ją oznaczyć jako aktywną i kliknąć prawym i tam już git.\n\n" +
"Trójkąt można złapać za rogi by zmienić kształt.\n\n" +
"Można jeszcze usunąć figurę klikająć Delejt na klawiaturze.");
}
}
| // usuwa ikonkę "i" z nagłówka
| import javafx.scene.control.Alert;
/**
* <b>Alert</b> zawierający instrukcje obsługi.
*/
public class Manual extends Alert {
public Manual() {
super(AlertType.INFORMATION);
this.setGraphic(null); // usuwa ikonkę <SUF>
this.setTitle("Instrukcja");
this.setHeaderText("Instrukcja");
this.setContentText(
"Aby zrobić figurę, trzeba wybrać jakąś z menu i przeciągnąć po tym białym. Tak jak w Ms Paint.\n\n" +
"Aby oznaczyć figurę jako aktywną, trzeba ją kliknąć lewym przyciskiem myszy.\n\n" +
"Aby przesunąć figurę trzeba ją oznaczyć jako aktywną, następnie złapać i przeciągnąć.\n\n" +
"Aby zmnienić rozmiar figury trzeba ją oznaczyć jako aktywną, najechać na nią myszką i pokręcić kółkiem.\n\n"
+
"Aby obrócić figurę trzeba ją oznaczyć jako aktywną, i przytrzymać Q lub E.\n\n" +
"Aby zmienić kolor figury trzeba ją oznaczyć jako aktywną i kliknąć prawym i tam już git.\n\n" +
"Trójkąt można złapać za rogi by zmienić kształt.\n\n" +
"Można jeszcze usunąć figurę klikająć Delejt na klawiaturze.");
}
}
| t |
5159_1 | KayakOnWheels/Grzegorz-Gajewski-Kodilla-Java | 434 | kodilla-rps/src/main/java/com/kodilla/rps/GameRules.java | package com.kodilla.rps;
import static com.kodilla.rps.RpsRunner.player1;
import static com.kodilla.rps.RpsRunner.player2;
public class GameRules {
/* final static private int rules[][] = {
{ 0,-1, 1},
{ 1, 0,-1},
{-1, 1, 0}
};*/
final static private int[][] rules = {
{ 0,-1, 1,-1, 1},
{ 1, 0,-1, 1,-1},
{-1, 1, 0,-1, 1},
{ 1,-1, 1, 0,-1},
{-1, 1,-1, 1, 0}
};
private static int numberOfRounds;
public static void whoWins(String player1Move, String player2Move) {
int score = rules[Integer.parseInt(player1Move)-1][Integer.parseInt(player2Move)-1];
if(score == 1) {
player1.addPoint();
System.out.println("Point for " + player1.getName());
} else if(score == -1) {
player2.addPoint();
System.out.println("Point for " + player2.getName());
} else {
System.out.println("Draw!");
}
System.out.println();
}
public static void setNumberOfRounds(int x) {
numberOfRounds = x; //dlaczego nie mogę tu użyć this?
}
public static int getNumberOfRounds() {
return numberOfRounds;
}
}
| //dlaczego nie mogę tu użyć this? | package com.kodilla.rps;
import static com.kodilla.rps.RpsRunner.player1;
import static com.kodilla.rps.RpsRunner.player2;
public class GameRules {
/* final static private int rules[][] = {
{ 0,-1, 1},
{ 1, 0,-1},
{-1, 1, 0}
};*/
final static private int[][] rules = {
{ 0,-1, 1,-1, 1},
{ 1, 0,-1, 1,-1},
{-1, 1, 0,-1, 1},
{ 1,-1, 1, 0,-1},
{-1, 1,-1, 1, 0}
};
private static int numberOfRounds;
public static void whoWins(String player1Move, String player2Move) {
int score = rules[Integer.parseInt(player1Move)-1][Integer.parseInt(player2Move)-1];
if(score == 1) {
player1.addPoint();
System.out.println("Point for " + player1.getName());
} else if(score == -1) {
player2.addPoint();
System.out.println("Point for " + player2.getName());
} else {
System.out.println("Draw!");
}
System.out.println();
}
public static void setNumberOfRounds(int x) {
numberOfRounds = x; //dlaczego nie <SUF>
}
public static int getNumberOfRounds() {
return numberOfRounds;
}
}
| t |
10518_0 | KimLoanSA/mimuw | 701 | sem3/pw/abrams/petri-net/src/petrinet/PetriNet.java | package petrinet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import petrinet.models.MutexAndTransitions;
import petrinet.models.State;
import petrinet.resolvers.PetriNetFireResolver;
import petrinet.resolvers.ReachableStatesResolver;
import petrinet.resolvers.TransitionMutexResolver;
public class PetriNet<T> {
private State<T> placesTokens;
private TransitionMutexResolver<T> mutexResolver;
public PetriNet(Map<T, Integer> initial, boolean fair) {
this.placesTokens = new State<>(initial);
this.mutexResolver = new TransitionMutexResolver<>(placesTokens, fair);
}
public Set<Map<T, Integer>> reachable(Collection<Transition<T>> transitions) {
ReachableStatesResolver<T> resolver = new ReachableStatesResolver<>(placesTokens, new ArrayList<>(transitions));
return resolver.findAll();
}
public Transition<T> fire(Collection<Transition<T>> transitions) throws InterruptedException {
List<Transition<T>> transitionsList = new ArrayList<>(transitions);
MutexAndTransitions<T> actualMutexAndTransitions = mutexResolver.getMutex(transitionsList);
try {
actualMutexAndTransitions
.getMutex()
.acquire();
} catch (InterruptedException e) {
mutexResolver.removeFromQueue(actualMutexAndTransitions);
throw e;
}
return fireReleaseAndSave(transitionsList, actualMutexAndTransitions);
}
private Transition<T> fireReleaseAndSave(List<Transition<T>> transitionsList,
MutexAndTransitions<T> actualMutexAndTransitions) {
PetriNetFireResolver<T> fireResolver = new PetriNetFireResolver<>(placesTokens);
Transition<T> transitionToFire = placesTokens
.findFirstTransitionEnabled(transitionsList)
.get(); // zawsze sie znajdzie bo dodaje do kolejki
placesTokens = fireResolver.fire(transitionToFire);
cleanMutex(actualMutexAndTransitions);
return transitionToFire;
}
private void cleanMutex(MutexAndTransitions<T> actualMutexAndTransitions) {
mutexResolver.removeFromQueue(actualMutexAndTransitions);
mutexResolver.updateStateAndReleaseNext(placesTokens);
}
}
| // zawsze sie znajdzie bo dodaje do kolejki | package petrinet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import petrinet.models.MutexAndTransitions;
import petrinet.models.State;
import petrinet.resolvers.PetriNetFireResolver;
import petrinet.resolvers.ReachableStatesResolver;
import petrinet.resolvers.TransitionMutexResolver;
public class PetriNet<T> {
private State<T> placesTokens;
private TransitionMutexResolver<T> mutexResolver;
public PetriNet(Map<T, Integer> initial, boolean fair) {
this.placesTokens = new State<>(initial);
this.mutexResolver = new TransitionMutexResolver<>(placesTokens, fair);
}
public Set<Map<T, Integer>> reachable(Collection<Transition<T>> transitions) {
ReachableStatesResolver<T> resolver = new ReachableStatesResolver<>(placesTokens, new ArrayList<>(transitions));
return resolver.findAll();
}
public Transition<T> fire(Collection<Transition<T>> transitions) throws InterruptedException {
List<Transition<T>> transitionsList = new ArrayList<>(transitions);
MutexAndTransitions<T> actualMutexAndTransitions = mutexResolver.getMutex(transitionsList);
try {
actualMutexAndTransitions
.getMutex()
.acquire();
} catch (InterruptedException e) {
mutexResolver.removeFromQueue(actualMutexAndTransitions);
throw e;
}
return fireReleaseAndSave(transitionsList, actualMutexAndTransitions);
}
private Transition<T> fireReleaseAndSave(List<Transition<T>> transitionsList,
MutexAndTransitions<T> actualMutexAndTransitions) {
PetriNetFireResolver<T> fireResolver = new PetriNetFireResolver<>(placesTokens);
Transition<T> transitionToFire = placesTokens
.findFirstTransitionEnabled(transitionsList)
.get(); // zawsze sie <SUF>
placesTokens = fireResolver.fire(transitionToFire);
cleanMutex(actualMutexAndTransitions);
return transitionToFire;
}
private void cleanMutex(MutexAndTransitions<T> actualMutexAndTransitions) {
mutexResolver.removeFromQueue(actualMutexAndTransitions);
mutexResolver.updateStateAndReleaseNext(placesTokens);
}
}
| t |
5288_0 | Kimel-PK/Java_2021-2022 | 181 | Zadanie 05/src/Color.java |
/**
* Typ wyliczeniowy reprezentujący kolory
*/
public enum Color {
BLACK, WHITE, GREEN, YELLOW, RED, ORANGE, PINK, ;
@Override
public String toString() {
return name().substring(0, 1);
}
/**
* Metoda main pozwalająca zobaczyć jak prezentowane są
* poszczególne kolory.
*/
public static void main(String[] args) {
for ( Color color : Color.values() ) {
System.out.println( color.name() + " -> " + color );
}
}
}
| /**
* Typ wyliczeniowy reprezentujący kolory
*/ |
/**
* Typ wyliczeniowy reprezentujący <SUF>*/
public enum Color {
BLACK, WHITE, GREEN, YELLOW, RED, ORANGE, PINK, ;
@Override
public String toString() {
return name().substring(0, 1);
}
/**
* Metoda main pozwalająca zobaczyć jak prezentowane są
* poszczególne kolory.
*/
public static void main(String[] args) {
for ( Color color : Color.values() ) {
System.out.println( color.name() + " -> " + color );
}
}
}
| t |
9022_0 | Kinggred/AdvancedJavaClass | 745 | src/First/Kolekcje.java | package First;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
public class Kolekcje {
public static void main(String[] args) {
System.out.println("ArrayList to lista, która pozwala przechowywać elementy zgodne z zadeklarowanym typem");
List<String> lista = new ArrayList<>();
lista.add("Jabłko");
lista.add("Banan");
lista.add("Gruszka");
System.out.println(lista); // [Jabłko, Banan, Gruszka]
System.out.println("HashSet to kolekcja, która przechowuje unikalne elementy w dowolnej kolejności");
Set<Integer> zbior = new HashSet<>();
zbior.add(1);
zbior.add(2);
zbior.add(1); // Ten element zostanie zignorowany, ponieważ jest duplikatem
System.out.println(zbior); // [1, 2]
System.out.println("HashMap to kolekcja typu klucz-wartość, która przechowuje pary obiektów");
Map<String, Integer> mapa = new HashMap<>();
mapa.put("Jan", 25);
mapa.put("Anna", 30);
mapa.put("Marek", 28);
System.out.println("Wiek Anny: " + mapa.get("Anna")); // Wiek Anny: 30
System.out.println("LinkedList to lista dwukierunkowa, która pozwala na efektywne dodawanie i usuwanie elementów na początku, końcu i w środku listy."); // Wiek Anny: 30
List<String> linkedLista = new LinkedList<>();
linkedLista.add("Pierwszy");
linkedLista.add("Drugi");
linkedLista.add("Trzeci");
System.out.println(linkedLista); // [Pierwszy, Drugi, Trzeci]
linkedLista.remove(1); // Usuwa drugi element
System.out.println(linkedLista); // [Pierwszy, Trzeci]
System.out.println("TreeSet to kolekcja, która przechowuje unikalne elementy w porządku naturalnym lub według dostarczonego komparatora");
Set<String> treeSet = new TreeSet<>();
treeSet.add("C");
treeSet.add("A");
treeSet.add("B");
System.out.println(treeSet); // [A, B, C] (uporządkowane alfabetycznie)
}
} | // [Jabłko, Banan, Gruszka] | package First;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
public class Kolekcje {
public static void main(String[] args) {
System.out.println("ArrayList to lista, która pozwala przechowywać elementy zgodne z zadeklarowanym typem");
List<String> lista = new ArrayList<>();
lista.add("Jabłko");
lista.add("Banan");
lista.add("Gruszka");
System.out.println(lista); // [Jabłko, Banan, <SUF>
System.out.println("HashSet to kolekcja, która przechowuje unikalne elementy w dowolnej kolejności");
Set<Integer> zbior = new HashSet<>();
zbior.add(1);
zbior.add(2);
zbior.add(1); // Ten element zostanie zignorowany, ponieważ jest duplikatem
System.out.println(zbior); // [1, 2]
System.out.println("HashMap to kolekcja typu klucz-wartość, która przechowuje pary obiektów");
Map<String, Integer> mapa = new HashMap<>();
mapa.put("Jan", 25);
mapa.put("Anna", 30);
mapa.put("Marek", 28);
System.out.println("Wiek Anny: " + mapa.get("Anna")); // Wiek Anny: 30
System.out.println("LinkedList to lista dwukierunkowa, która pozwala na efektywne dodawanie i usuwanie elementów na początku, końcu i w środku listy."); // Wiek Anny: 30
List<String> linkedLista = new LinkedList<>();
linkedLista.add("Pierwszy");
linkedLista.add("Drugi");
linkedLista.add("Trzeci");
System.out.println(linkedLista); // [Pierwszy, Drugi, Trzeci]
linkedLista.remove(1); // Usuwa drugi element
System.out.println(linkedLista); // [Pierwszy, Trzeci]
System.out.println("TreeSet to kolekcja, która przechowuje unikalne elementy w porządku naturalnym lub według dostarczonego komparatora");
Set<String> treeSet = new TreeSet<>();
treeSet.add("C");
treeSet.add("A");
treeSet.add("B");
System.out.println(treeSet); // [A, B, C] (uporządkowane alfabetycznie)
}
} | t |
6308_2 | Kiririridev/PomodoroTimer | 2,875 | src/pomodorotimer/view/TabPaneController.java | package pomodorotimer.view;
import java.net.URL;
import java.time.LocalDate;
import java.util.ResourceBundle;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.chart.BarChart;
import javafx.scene.chart.CategoryAxis;
import javafx.scene.chart.NumberAxis;
import javafx.scene.chart.XYChart;
import javafx.scene.control.Button;
import javafx.scene.control.ChoiceBox;
import javafx.scene.control.Label;
import javafx.scene.control.ProgressIndicator;
import javafx.scene.control.Slider;
import javafx.scene.control.Tab;
import javafx.scene.control.TabPane;
import javafx.scene.control.TextArea;
import javafx.scene.image.ImageView;
import javafx.scene.layout.AnchorPane;
import pomodorotimer.model.*;
import pomodorotimer.PomodoroTimer;
/**
*
* @author Bartlomiej Kirejczyk
*/
public class TabPaneController implements Initializable {
TabPaneController tabPaneController;
StatisticHolder statistics;
@FXML
private BarChart<?, ?> barChart;
@FXML
private TabPane tabPane;
@FXML
private Tab tabTimer;
@FXML
private AnchorPane anchorPaneTimer;
@FXML
private Slider sliderWork;
@FXML
private Label labelWork;
@FXML
private Label labelBreak;
@FXML
private Button buttonStartWork;
@FXML
private Button buttonStartBreak;
@FXML
private Slider sliderBreak;
@FXML
private Tab tabStatistics;
@FXML
private AnchorPane anchorPaneStatistics;
@FXML
private Tab tabAbout;
@FXML
private AnchorPane achorPaneAbout;
@FXML
private TextArea textAreaAbout;
@FXML
private ImageView imageViewAbout;
@FXML
private ProgressIndicator progressIndicatorWork;
@FXML
private ProgressIndicator progressIndicatorBreak;
@FXML
private NumberAxis numberAxis;
@FXML
private CategoryAxis categoryAxis;
//obiekty wykresu
/**
* Sets labels text and progress bars to 0.0
* @param url
* @param rb
*/
@Override
public void initialize(URL url, ResourceBundle rb)
{
labelWork.setText(Integer.toString((int)sliderWork.getValue()) + " minutes");
labelBreak.setText(Integer.toString((int)sliderBreak.getValue()) + " minutes");
progressIndicatorWork.setProgress(0.0);
progressIndicatorBreak.setProgress(0.0);
//statystyki i wykres
statistics = PomodoroTimer.getStatisticHolder();
XYChart.Series xyChart = new XYChart.Series<>();
for(int i = 6; i>=0; i--)
{
System.out.println(statistics.getWorkDate(i).getDate().toString() + statistics.getWorkDate(i).getWorkMins());
xyChart.getData().add(new XYChart.Data<>(statistics.getWorkDate(i).getDate().toString(), statistics.getWorkDate(i).getWorkMins()));
}
barChart.getData().addAll(xyChart);
}
/**
* Creates object WorkTimer. Passes time goal from slider. Changes Labels text to cancel and pause.
* Pause doesn't stop timer, it stops incrementing time. When "pause" is clicked it changes label text to "pasued"
*/
@FXML
public void onActionStartWork()
{
WorkTimer workTimer;
workTimer = new WorkTimer((int)sliderWork.getValue());
//metoda zmienia przyciski
//disabluje i zmienia tekst buttonStartBreak
this.buttonStartBreak.setText("Pause");
this.buttonStartBreak.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event)
{
workTimer.pause();
}
});
this.progressIndicatorBreak.setProgress(0);
//i zmienia tekst i przeznaczenie buttonStartWork
this.buttonStartWork.setText("Cancel");
this.buttonStartWork.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
workTimer.cancel();
}
});
}
/**
* actualizes text on workLabel when using slider
*/
@FXML
public void actualizeLabelWork()
{
labelWork.setText(Integer.toString((int)sliderWork.getValue()) + " minutes");
}
//resetuje buttonStartWork, nadaje mu pierwotny tekst i pierwotny on ActionEvent
/**
* resets buttonStart work to previous text and ActionEvent
*/
@FXML
public void resetbuttonStartWork()
{
//nie rozumiem do końca tego rozwiazania, nie przerabiałem jeszcze wielowątkowości
//bład był spowodowany tym, że tylko wątek JavyFX moze edytować tekst przycisków
//zmiana tekstu przez wątek timera bez Platform.runLater wywoływała błąd
Platform.runLater(new Runnable()
{
@Override
public void run()
{
buttonStartWork.setDisable(false);
buttonStartWork.setText("Start Work");
}
});
//changes button ActionEvent to basic one
buttonStartWork.setOnAction(new EventHandler<ActionEvent> () {
@Override
public void handle(ActionEvent event)
{
onActionStartWork();
}
});
}
/**
* Creates object BreakTimer. Passes time goal from slider. Changes Labels text to cancel and pause.
* Pause doesn't stop timer, it stops incrementing time. When "pause" is clicked it changes label text to "pasued".
* Stats from this one aren;t saved
*/
@FXML
public void onActionStartBreak()
{
BreakTimer breakTimer;
breakTimer = new BreakTimer((int)sliderBreak.getValue());
this.buttonStartWork.setText("Pause");
this.buttonStartWork.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event)
{
breakTimer.pause();
}
});
this.progressIndicatorWork.setProgress(0);
this.buttonStartBreak.setText("Cancel");
this.buttonStartBreak.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
breakTimer.cancel();
}
});
}
/**
* actualizes text on labale when using slider
*/
@FXML
public void actualizeLabelBreak()
{
labelBreak.setText(Integer.toString((int)sliderBreak.getValue()) + " minutes");
}
//resetuje buttonStartBreak
@FXML
public void resetButtonStartBreak()
{
//solves problem that JavaFX had with multithreading
Platform.runLater(new Runnable()
{
@Override
public void run()
{
buttonStartBreak.setText("Start Break");
buttonStartBreak.setDisable(false);
}
});
//sets previous Action Event on button
buttonStartBreak.setOnAction(new EventHandler<ActionEvent>()
{
@Override
public void handle(ActionEvent event)
{
onActionStartBreak();
}
});
}
//actualizes Progress Indicator work
@FXML
public void actualizeWorkProgressIndicator(double progress)
{
progressIndicatorWork.setProgress(progress);
}
//acualizes Prograss Indicator break
@FXML
public void actualizeBreakProgressIndicator(double progress)
{
progressIndicatorBreak.setProgress(progress);
}
//sets both progress indicators to 0.0
@FXML
public void resetProgressIndocators()
{
this.progressIndicatorBreak.setProgress(0.0);
this.progressIndicatorWork.setProgress(0.0);
}
//resets both buttons
@FXML
public void resetButtons()
{
this.resetButtonStartBreak();
this.resetbuttonStartWork();
}
//changes text of labels according to status of timer
@FXML
public void switchPauseBreakButton(boolean isPaused)
{
if(isPaused)
{
this.buttonStartBreak.setText("Paused");
}else
{
this.buttonStartBreak.setText("Pause");
}
}
//changes text of labels according to status of timer
@FXML
public void switchPauseWorkButton(boolean isPaused)
{
if(isPaused)
{
this.buttonStartWork.setText("Paused");
}else
{
this.buttonStartWork.setText("Pause");
}
}
//refreshes chart
@FXML
public void refreshChart()
{
Platform.runLater(new Runnable()
{
@Override
public void run(){
XYChart.Series xyChart = new XYChart.Series<>();
for(int i = 6; i>=0; i--)
{
//System.out.println(statistics.getWorkDate(i).getDate().toString() + statistics.getWorkDate(i).getWorkMins());
xyChart.getData().add(new XYChart.Data<>(statistics.getWorkDate(i).getDate().toString(), statistics.getWorkDate(i).getWorkMins()));
}
barChart.getData().clear();
barChart.getData().addAll(xyChart);
}});
}
}
| //statystyki i wykres
| package pomodorotimer.view;
import java.net.URL;
import java.time.LocalDate;
import java.util.ResourceBundle;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.chart.BarChart;
import javafx.scene.chart.CategoryAxis;
import javafx.scene.chart.NumberAxis;
import javafx.scene.chart.XYChart;
import javafx.scene.control.Button;
import javafx.scene.control.ChoiceBox;
import javafx.scene.control.Label;
import javafx.scene.control.ProgressIndicator;
import javafx.scene.control.Slider;
import javafx.scene.control.Tab;
import javafx.scene.control.TabPane;
import javafx.scene.control.TextArea;
import javafx.scene.image.ImageView;
import javafx.scene.layout.AnchorPane;
import pomodorotimer.model.*;
import pomodorotimer.PomodoroTimer;
/**
*
* @author Bartlomiej Kirejczyk
*/
public class TabPaneController implements Initializable {
TabPaneController tabPaneController;
StatisticHolder statistics;
@FXML
private BarChart<?, ?> barChart;
@FXML
private TabPane tabPane;
@FXML
private Tab tabTimer;
@FXML
private AnchorPane anchorPaneTimer;
@FXML
private Slider sliderWork;
@FXML
private Label labelWork;
@FXML
private Label labelBreak;
@FXML
private Button buttonStartWork;
@FXML
private Button buttonStartBreak;
@FXML
private Slider sliderBreak;
@FXML
private Tab tabStatistics;
@FXML
private AnchorPane anchorPaneStatistics;
@FXML
private Tab tabAbout;
@FXML
private AnchorPane achorPaneAbout;
@FXML
private TextArea textAreaAbout;
@FXML
private ImageView imageViewAbout;
@FXML
private ProgressIndicator progressIndicatorWork;
@FXML
private ProgressIndicator progressIndicatorBreak;
@FXML
private NumberAxis numberAxis;
@FXML
private CategoryAxis categoryAxis;
//obiekty wykresu
/**
* Sets labels text and progress bars to 0.0
* @param url
* @param rb
*/
@Override
public void initialize(URL url, ResourceBundle rb)
{
labelWork.setText(Integer.toString((int)sliderWork.getValue()) + " minutes");
labelBreak.setText(Integer.toString((int)sliderBreak.getValue()) + " minutes");
progressIndicatorWork.setProgress(0.0);
progressIndicatorBreak.setProgress(0.0);
//statystyki i <SUF>
statistics = PomodoroTimer.getStatisticHolder();
XYChart.Series xyChart = new XYChart.Series<>();
for(int i = 6; i>=0; i--)
{
System.out.println(statistics.getWorkDate(i).getDate().toString() + statistics.getWorkDate(i).getWorkMins());
xyChart.getData().add(new XYChart.Data<>(statistics.getWorkDate(i).getDate().toString(), statistics.getWorkDate(i).getWorkMins()));
}
barChart.getData().addAll(xyChart);
}
/**
* Creates object WorkTimer. Passes time goal from slider. Changes Labels text to cancel and pause.
* Pause doesn't stop timer, it stops incrementing time. When "pause" is clicked it changes label text to "pasued"
*/
@FXML
public void onActionStartWork()
{
WorkTimer workTimer;
workTimer = new WorkTimer((int)sliderWork.getValue());
//metoda zmienia przyciski
//disabluje i zmienia tekst buttonStartBreak
this.buttonStartBreak.setText("Pause");
this.buttonStartBreak.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event)
{
workTimer.pause();
}
});
this.progressIndicatorBreak.setProgress(0);
//i zmienia tekst i przeznaczenie buttonStartWork
this.buttonStartWork.setText("Cancel");
this.buttonStartWork.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
workTimer.cancel();
}
});
}
/**
* actualizes text on workLabel when using slider
*/
@FXML
public void actualizeLabelWork()
{
labelWork.setText(Integer.toString((int)sliderWork.getValue()) + " minutes");
}
//resetuje buttonStartWork, nadaje mu pierwotny tekst i pierwotny on ActionEvent
/**
* resets buttonStart work to previous text and ActionEvent
*/
@FXML
public void resetbuttonStartWork()
{
//nie rozumiem do końca tego rozwiazania, nie przerabiałem jeszcze wielowątkowości
//bład był spowodowany tym, że tylko wątek JavyFX moze edytować tekst przycisków
//zmiana tekstu przez wątek timera bez Platform.runLater wywoływała błąd
Platform.runLater(new Runnable()
{
@Override
public void run()
{
buttonStartWork.setDisable(false);
buttonStartWork.setText("Start Work");
}
});
//changes button ActionEvent to basic one
buttonStartWork.setOnAction(new EventHandler<ActionEvent> () {
@Override
public void handle(ActionEvent event)
{
onActionStartWork();
}
});
}
/**
* Creates object BreakTimer. Passes time goal from slider. Changes Labels text to cancel and pause.
* Pause doesn't stop timer, it stops incrementing time. When "pause" is clicked it changes label text to "pasued".
* Stats from this one aren;t saved
*/
@FXML
public void onActionStartBreak()
{
BreakTimer breakTimer;
breakTimer = new BreakTimer((int)sliderBreak.getValue());
this.buttonStartWork.setText("Pause");
this.buttonStartWork.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event)
{
breakTimer.pause();
}
});
this.progressIndicatorWork.setProgress(0);
this.buttonStartBreak.setText("Cancel");
this.buttonStartBreak.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
breakTimer.cancel();
}
});
}
/**
* actualizes text on labale when using slider
*/
@FXML
public void actualizeLabelBreak()
{
labelBreak.setText(Integer.toString((int)sliderBreak.getValue()) + " minutes");
}
//resetuje buttonStartBreak
@FXML
public void resetButtonStartBreak()
{
//solves problem that JavaFX had with multithreading
Platform.runLater(new Runnable()
{
@Override
public void run()
{
buttonStartBreak.setText("Start Break");
buttonStartBreak.setDisable(false);
}
});
//sets previous Action Event on button
buttonStartBreak.setOnAction(new EventHandler<ActionEvent>()
{
@Override
public void handle(ActionEvent event)
{
onActionStartBreak();
}
});
}
//actualizes Progress Indicator work
@FXML
public void actualizeWorkProgressIndicator(double progress)
{
progressIndicatorWork.setProgress(progress);
}
//acualizes Prograss Indicator break
@FXML
public void actualizeBreakProgressIndicator(double progress)
{
progressIndicatorBreak.setProgress(progress);
}
//sets both progress indicators to 0.0
@FXML
public void resetProgressIndocators()
{
this.progressIndicatorBreak.setProgress(0.0);
this.progressIndicatorWork.setProgress(0.0);
}
//resets both buttons
@FXML
public void resetButtons()
{
this.resetButtonStartBreak();
this.resetbuttonStartWork();
}
//changes text of labels according to status of timer
@FXML
public void switchPauseBreakButton(boolean isPaused)
{
if(isPaused)
{
this.buttonStartBreak.setText("Paused");
}else
{
this.buttonStartBreak.setText("Pause");
}
}
//changes text of labels according to status of timer
@FXML
public void switchPauseWorkButton(boolean isPaused)
{
if(isPaused)
{
this.buttonStartWork.setText("Paused");
}else
{
this.buttonStartWork.setText("Pause");
}
}
//refreshes chart
@FXML
public void refreshChart()
{
Platform.runLater(new Runnable()
{
@Override
public void run(){
XYChart.Series xyChart = new XYChart.Series<>();
for(int i = 6; i>=0; i--)
{
//System.out.println(statistics.getWorkDate(i).getDate().toString() + statistics.getWorkDate(i).getWorkMins());
xyChart.getData().add(new XYChart.Data<>(statistics.getWorkDate(i).getDate().toString(), statistics.getWorkDate(i).getWorkMins()));
}
barChart.getData().clear();
barChart.getData().addAll(xyChart);
}});
}
}
| t |
5794_3 | Kleszczz/Java-school-PJATK | 379 | src/PPJ18/Main.java | package PPJ18;
//2021-12-03 - PPJ18
public class Main {
public static void main(String[] args){
Person Adam = new Person();
Adam.name = "Adam";
Adam.surname = "Kowalski";
Adam.birthyear = 2002;
Fruit Mango = new Fruit("Mango");
Mango.show();
Ballon balon1 = new Ballon();
Donkey Osiol = new Donkey();
Osiol.addBaloon(balon1);
//isflying oczywiście da nam false, bo jeden balon nie wystarczy
System.out.println(Osiol.isFlying());
//pętlujemy tak długo aż isflying da nam true
//czyli kiedy masa osla bedzie mniejsza od balonow
while(!Osiol.isFlying()){
Ballon balonPetla = new Ballon();
Osiol.addBaloon(balonPetla);
} //potem po prostu wypisujemy, bo jak petla sie udala
System.out.println("Ja latam! ");
//zad5
Point2D punktNr1 = new Point2D();
int[] pointsArray = {3,2};
punktNr1.set(pointsArray);
System.out.println(punktNr1.get());
}
}
| //czyli kiedy masa osla bedzie mniejsza od balonow | package PPJ18;
//2021-12-03 - PPJ18
public class Main {
public static void main(String[] args){
Person Adam = new Person();
Adam.name = "Adam";
Adam.surname = "Kowalski";
Adam.birthyear = 2002;
Fruit Mango = new Fruit("Mango");
Mango.show();
Ballon balon1 = new Ballon();
Donkey Osiol = new Donkey();
Osiol.addBaloon(balon1);
//isflying oczywiście da nam false, bo jeden balon nie wystarczy
System.out.println(Osiol.isFlying());
//pętlujemy tak długo aż isflying da nam true
//czyli kiedy <SUF>
while(!Osiol.isFlying()){
Ballon balonPetla = new Ballon();
Osiol.addBaloon(balonPetla);
} //potem po prostu wypisujemy, bo jak petla sie udala
System.out.println("Ja latam! ");
//zad5
Point2D punktNr1 = new Point2D();
int[] pointsArray = {3,2};
punktNr1.set(pointsArray);
System.out.println(punktNr1.get());
}
}
| t |
6868_2 | Konrad66/small-projects | 312 | male-zadania/src/main/java/org/example/basics/exe25/Exercise25.java | package org.example.basics.exe25;
public class Exercise25 {
//TODO do sprawdzenia - przeanalizowac
public static void main(String[] args) {
int numbers[] = {-65, -60, -70, -38, -43, -6, -24, -97, -23, -27};
double sum = 0;
for (int number : numbers) {
sum += number;
}
System.out.println("Average of numbers equals: " + sum / numbers.length);
//TODO zapytac dlaczego min a nie max value
int maxNumber = Integer.MIN_VALUE;
for (int number : numbers) {
if (number > maxNumber) {
maxNumber = number;
}
}
System.out.println("The greatest number is: " + maxNumber);
//TODO zapytac dlacze man a nie min value
int minValue = Integer.MAX_VALUE;
for (int number : numbers) {
if (number < minValue) {
minValue = number;
}
}
System.out.println("The lowest number is: " + minValue);
}
}
| //TODO zapytac dlacze man a nie min value | package org.example.basics.exe25;
public class Exercise25 {
//TODO do sprawdzenia - przeanalizowac
public static void main(String[] args) {
int numbers[] = {-65, -60, -70, -38, -43, -6, -24, -97, -23, -27};
double sum = 0;
for (int number : numbers) {
sum += number;
}
System.out.println("Average of numbers equals: " + sum / numbers.length);
//TODO zapytac dlaczego min a nie max value
int maxNumber = Integer.MIN_VALUE;
for (int number : numbers) {
if (number > maxNumber) {
maxNumber = number;
}
}
System.out.println("The greatest number is: " + maxNumber);
//TODO zapytac <SUF>
int minValue = Integer.MAX_VALUE;
for (int number : numbers) {
if (number < minValue) {
minValue = number;
}
}
System.out.println("The lowest number is: " + minValue);
}
}
| t |
8461_2 | Kosh4tina/PJATK | 419 | MAS/MP2_MAS/src/Produkt.java | import java.util.ArrayList;
/*** ASOCJACJA KWALIFIKOWANA ***/
public class Produkt {
private String nazwa;
private int nrKolejny;
private ArrayList<Meal> meal = new ArrayList<>(); // przechowywanie informacji zwrotnej
public Produkt(int nrKolejny, String nazwa) {
this.setNrKolejny(nrKolejny);
this.nazwa = nazwa;
}
public void addMeal(Meal nowyMeal)
{
if(!meal.contains(nowyMeal)) { // Sprawdz czy nie mamy juz takiej informacji
meal.add(nowyMeal);
nowyMeal.addProduktKwalif(this); // Dodaj informacje zwrotna
}
}
public String toString() {
System.out.println("----------------------");
String zwrot = "PRODUKT: " + nazwa + "\n";
zwrot += "WCHODZI W SKЈAD POSIЈKU: ";
for(Meal p : meal) {
zwrot += p.getNazwa()+ "\n";
}
return zwrot;
}
public int getNrKolejny() {
return nrKolejny;
}
public void setNrKolejny(int nrKolejny) {
this.nrKolejny = nrKolejny;
}
}
| // Dodaj informacje zwrotna
| import java.util.ArrayList;
/*** ASOCJACJA KWALIFIKOWANA ***/
public class Produkt {
private String nazwa;
private int nrKolejny;
private ArrayList<Meal> meal = new ArrayList<>(); // przechowywanie informacji zwrotnej
public Produkt(int nrKolejny, String nazwa) {
this.setNrKolejny(nrKolejny);
this.nazwa = nazwa;
}
public void addMeal(Meal nowyMeal)
{
if(!meal.contains(nowyMeal)) { // Sprawdz czy nie mamy juz takiej informacji
meal.add(nowyMeal);
nowyMeal.addProduktKwalif(this); // Dodaj informacje <SUF>
}
}
public String toString() {
System.out.println("----------------------");
String zwrot = "PRODUKT: " + nazwa + "\n";
zwrot += "WCHODZI W SKЈAD POSIЈKU: ";
for(Meal p : meal) {
zwrot += p.getNazwa()+ "\n";
}
return zwrot;
}
public int getNrKolejny() {
return nrKolejny;
}
public void setNrKolejny(int nrKolejny) {
this.nrKolejny = nrKolejny;
}
}
| t |
8330_2 | Koziolek/ragecomicsmaker | 1,490 | src/main/java/pl/koziolekweb/ragecomicsmaker/model/Comic.java | package pl.koziolekweb.ragecomicsmaker.model;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import pl.koziolekweb.ragecomicsmaker.App;
import pl.koziolekweb.ragecomicsmaker.event.ErrorEvent;
import pl.koziolekweb.ragecomicsmaker.xml.DirectionAdapter;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.io.File;
import java.io.Serializable;
import java.util.Collection;
import java.util.TreeSet;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
/**
* TODO write JAVADOC!!!
* User: koziolek
*/
@XmlRootElement(name = "comic")
public class Comic implements Serializable {
@XmlAttribute(required = true)
private int version;
@XmlAttribute(required = true)
private String id;
@XmlAttribute(required = true)
private String title;
@XmlAttribute(required = true)
@XmlJavaTypeAdapter(DirectionAdapter.class)
private Direction direction;
@XmlAttribute(required = true)
private String orientation;
@XmlAttribute(required = true)
private String transition;
@XmlAttribute(required = true)
private String bgcolor;
@XmlElement
private Images images;
@XmlElement(name = "screen")
private TreeSet<Screen> screens = new TreeSet<Screen>();
public Comic() {
initDefaults();
}
/**
* Methods to init object with default values. Need in first sprint.
*
* @return Comic with default values
*/
public Comic initDefaults() {
this.version = 0;
this.id = "";
this.title = "";
this.direction = Direction.LTR;
this.orientation = "";
this.transition = "";
this.bgcolor = "#FFFFFF";
this.images = new Images().initDefaults();
return this;
}
public void addScreen(Screen screen) {
screens.add(screen);
images.setLength(screens.size());
}
@XmlTransient
public Images getImages() {
return images;
}
public void setImages(Images images) {
this.images = images;
}
@XmlTransient
public TreeSet<Screen> getScreens() {
return screens;
}
public void setScreens(TreeSet<Screen> screens) {
this.screens = screens;
}
@XmlTransient
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
@XmlTransient
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@XmlTransient
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
@XmlTransient
public Direction getDirection() {
return direction;
}
public void setDirection(Direction direction) {
this.direction = direction;
}
@XmlTransient
public String getOrientation() {
return orientation;
}
public void setOrientation(String orientation) {
this.orientation = orientation;
}
@XmlTransient
public String getTransition() {
return transition;
}
public void setTransition(String transition) {
this.transition = transition;
}
@XmlTransient
public String getBgcolor() {
return bgcolor;
}
public void setBgcolor(String bgcolor) {
this.bgcolor = bgcolor;
}
public Screen findScreenByFileName(final String lastSelectedPathComponent) {
checkNotNull(lastSelectedPathComponent);
Collection<Screen> filtered = Collections2.filter(screens, new Predicate<Screen>() {
@Override
public boolean apply(Screen input) {
File image = input.getImage();
if (image == null) return false;
return lastSelectedPathComponent.equals(image.getName());
}
});
checkState(filtered.size() == 1);
return filtered.iterator().next();
}
public Screen findScreenByIndex(String number) {
try {
final int intNumber = Integer.parseInt(number);
Collection<Screen> filtered = Collections2.filter(screens, new Predicate<Screen>() {
@Override
public boolean apply(Screen input) {
return input.getIndex() == intNumber;
}
});
if (filtered.iterator().hasNext())
return filtered.iterator().next();
return new Screen(); // tak naprawdę do niczego nie podpiety null object
} catch (Exception e) {
App.EVENT_BUS.post(new ErrorEvent("Nieoczekiwany błąd odczytu - nieprawidłowy numer pliku " + number, e));
return new Screen();
}
}
}
| // tak naprawdę do niczego nie podpiety null object | package pl.koziolekweb.ragecomicsmaker.model;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import pl.koziolekweb.ragecomicsmaker.App;
import pl.koziolekweb.ragecomicsmaker.event.ErrorEvent;
import pl.koziolekweb.ragecomicsmaker.xml.DirectionAdapter;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.io.File;
import java.io.Serializable;
import java.util.Collection;
import java.util.TreeSet;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
/**
* TODO write JAVADOC!!!
* User: koziolek
*/
@XmlRootElement(name = "comic")
public class Comic implements Serializable {
@XmlAttribute(required = true)
private int version;
@XmlAttribute(required = true)
private String id;
@XmlAttribute(required = true)
private String title;
@XmlAttribute(required = true)
@XmlJavaTypeAdapter(DirectionAdapter.class)
private Direction direction;
@XmlAttribute(required = true)
private String orientation;
@XmlAttribute(required = true)
private String transition;
@XmlAttribute(required = true)
private String bgcolor;
@XmlElement
private Images images;
@XmlElement(name = "screen")
private TreeSet<Screen> screens = new TreeSet<Screen>();
public Comic() {
initDefaults();
}
/**
* Methods to init object with default values. Need in first sprint.
*
* @return Comic with default values
*/
public Comic initDefaults() {
this.version = 0;
this.id = "";
this.title = "";
this.direction = Direction.LTR;
this.orientation = "";
this.transition = "";
this.bgcolor = "#FFFFFF";
this.images = new Images().initDefaults();
return this;
}
public void addScreen(Screen screen) {
screens.add(screen);
images.setLength(screens.size());
}
@XmlTransient
public Images getImages() {
return images;
}
public void setImages(Images images) {
this.images = images;
}
@XmlTransient
public TreeSet<Screen> getScreens() {
return screens;
}
public void setScreens(TreeSet<Screen> screens) {
this.screens = screens;
}
@XmlTransient
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
@XmlTransient
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@XmlTransient
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
@XmlTransient
public Direction getDirection() {
return direction;
}
public void setDirection(Direction direction) {
this.direction = direction;
}
@XmlTransient
public String getOrientation() {
return orientation;
}
public void setOrientation(String orientation) {
this.orientation = orientation;
}
@XmlTransient
public String getTransition() {
return transition;
}
public void setTransition(String transition) {
this.transition = transition;
}
@XmlTransient
public String getBgcolor() {
return bgcolor;
}
public void setBgcolor(String bgcolor) {
this.bgcolor = bgcolor;
}
public Screen findScreenByFileName(final String lastSelectedPathComponent) {
checkNotNull(lastSelectedPathComponent);
Collection<Screen> filtered = Collections2.filter(screens, new Predicate<Screen>() {
@Override
public boolean apply(Screen input) {
File image = input.getImage();
if (image == null) return false;
return lastSelectedPathComponent.equals(image.getName());
}
});
checkState(filtered.size() == 1);
return filtered.iterator().next();
}
public Screen findScreenByIndex(String number) {
try {
final int intNumber = Integer.parseInt(number);
Collection<Screen> filtered = Collections2.filter(screens, new Predicate<Screen>() {
@Override
public boolean apply(Screen input) {
return input.getIndex() == intNumber;
}
});
if (filtered.iterator().hasNext())
return filtered.iterator().next();
return new Screen(); // tak naprawdę <SUF>
} catch (Exception e) {
App.EVENT_BUS.post(new ErrorEvent("Nieoczekiwany błąd odczytu - nieprawidłowy numer pliku " + number, e));
return new Screen();
}
}
}
| t |
9055_26 | KrajewskiMaciej/PO169709 | 3,023 | Cw_1/src/Main.java | import java.util.Scanner;
// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.
public class Main {
public static void zad1(){
//Napisz prostą aplikację kalkulatora tekstowego,
// która przyjmuje dwa liczby od użytkownika jako wejście
// i wykonuje podstawowe operacje matematyczne (dodawanie, odejmowanie, mnożenie, dzielenie).
// Wyświetl wyniki na ekranie.
System.out.print("Podaj pierwszą liczbę: ");
Scanner scanner = new Scanner(System.in);
double l1 = scanner.nextDouble();
System.out.print("Podaj drugą liczbę: ");
double l2 = scanner.nextDouble();
System.out.println("Wynik dodawania: " + (l1+l2));
System.out.println("Wynik odejmowania: " + (l1-l2));
System.out.println("Wynik mnożenia: " + (l1*l2));
System.out.println("Wynik dzielenia: " + (l1/l2));
}
public static void zad2(){
//Napisz program, który wczytuje ze standardowego wejścia dwa łańcuchy znaków,
// a następnie wypisuje je w kolejnych wierszach na standardowym wyjściu.
System.out.print("Podaj pierwszy łańcuch znaków:");
Scanner scanner =new Scanner(System.in);
String z1 = scanner.nextLine();
System.out.print("Podaj drugi łańcuch znaków:");
String z2 = scanner.nextLine();
System.out.println(z1);
System.out.println(z2);
}
public static void zad3(){
//Napisz program, który wczytuje ze standardowego wejścia cztery liczby wymierne,
// a następnie wypisuje ich sumę na standardowym wyjściu.
double suma=0;
for(int i=1;i<5;i++) {
System.out.println("Podaj liczbę wymierną nr" + i + ":");
Scanner scanner = new Scanner(System.in);
double liczba = scanner.nextDouble();
suma+=liczba;
}
System.out.println("Suma czterech liczb wynosi: "+suma);
}
public static void zad4(){
//Napisz program, który przyjmuje trzy liczby całkowite jako argumenty
// i zwraca największą z nich. Zastosuj instrukcje warunkowe do porównania liczb.
System.out.println("Podaj pierwszą liczbę całkowitą: ");
Scanner scanner = new Scanner(System.in);
int l1 = scanner.nextInt();
System.out.println("Podaj drugą liczbę całkowitą: ");
int l2 = scanner.nextInt();
System.out.println("Podaj trzecią liczbę całkowitą: ");
int l3 = scanner.nextInt();
if(l1>l2 && l1>l3){
System.out.println("Liczba "+ l1 + " jest największa");
}
else if(l3>l1 && l3>l2){
System.out.println("Liczba "+ l3 + " jest największa");
}
else{
System.out.println("Liczba "+ l2 + " jest największa");
}
}
public static void zad5(){
//Napisz program, który na podstawie podanego jako argument numeru dnia tygodnia (od 1 do 7) wypisze nazwę tego dnia tygodnia.
// Dla przykładu, jeżeli użytkownik poda liczbę 1, program powinien wypisać “Poniedziałek”.
// Jeżeli podana liczba nie jest z zakresu od 1 do 7,
// program powinien wyświetlić komunikat “Niepoprawny numer dnia tygodnia”.
System.out.println("Podaj numer dnia tygodnia z zakresu 1-7: ");
Scanner skaner = new Scanner(System.in);
int dzien = skaner.nextInt();
switch(dzien){
case 1:
System.out.println("Poniedziałek");
break;
case 2:
System.out.println("Wtorek");
break;
case 3:
System.out.println("Środa");
break;
case 4:
System.out.println("Czwartek");
break;
case 5:
System.out.println("PIĄTEK");
break;
case 6:
System.out.println("Sobota");
break;
case 7:
System.out.println("Niedziela");
break;
default:
System.out.println("Niepoprawny numer dnia tygodnia");
}
}
public static void zad6(){
//Napisz program, który będzie sprawdzał, czy podany rok jest rokiem przestępnym.
// Rok jest przestępny, jeśli jest podzielny przez 4, ale nie jest podzielny przez 100,
// chyba że jest podzielny przez 400
System.out.println("Podaj rok: ");
Scanner skaner = new Scanner(System.in);
int rok = skaner.nextInt();
if(rok%100==0){
if (rok % 400 == 0) {
System.out.println("Podany rok jest przestępny.");
}
else{
System.out.println("Podany rok nie jest przestępny.");
}
}
else if(rok%4==0){
System.out.println("Podany rok jest przestępny.");
}
else{
System.out.println("Podany rok nie jest przestępny.");
}
}
public static void zad7(){
//Napisz program, który oblicza sumę cyfr dowolnej wprowadzonej liczby.
// Program powinien akceptować liczbę jako input od użytkownika.
System.out.print("Podaj liczbę: ");
Scanner skaner= new Scanner(System.in);
int liczba = skaner.nextInt();
int suma =0;
int cyfra=liczba;
while (cyfra !=0) {
suma+= cyfra%10;
cyfra/=10;
}
System.out.println("Suma cyfr liczby "+liczba+" wynosi: "+suma);
}
public static void zad8(){
//Napisz program, który tworzy tablicę jednowymiarową 10 liczb całkowitych,
// a następnie wyświetla je w konsoli w porządku odwrotnym do wprowadzenia.
int[] tablica = new int[10];
Scanner scanner=new Scanner(System.in);
// Wprowadzenie liczb do tablicy
for (int i=0;i<10;i++) {
System.out.print("Podaj liczbę " +(i+1)+ ": ");
tablica[i] =scanner.nextInt();
}
System.out.println("Liczby w odwrotnej kolejności:");
for (int i=9;i>=0;i--) {
System.out.printf(tablica[i]+",");
}
}
public static void zad9(){
//Napisz program, który przyjmuje napis jako wejście
// i wypisuje wszystkie znaki znajdujące się na parzystych indeksach napisu, używając metody charAt.
System.out.print("Podaj napis: ");
Scanner scanner = new Scanner(System.in);
String napis =scanner.nextLine();
System.out.println("Znaki na parzystych indeksach:");
for (int i=0;i<napis.length();i+=2) {
char znak= napis.charAt(i);
System.out.printf(znak+",");
}
}
public static void zad10(){
//Napisz program, który przyjmuje jako wejście pojedynczy znak oraz liczbę całkowitą n.
// Używając klasy StringBuilder, zbuduj i wypisz piramidę o wysokości n,
// gdzie każdy poziom piramidy składa się z podanego znaku.
System.out.print("Podaj znak: ");
Scanner scanner = new Scanner(System.in);
char znak = scanner.next().charAt(0);
System.out.print("Podaj wysokość piramidy (liczba całkowita): ");
int n = scanner.nextInt();
if (n<=0) {
System.out.println("Wysokość piramidy musi być liczbą dodatnią.");
} else {
StringBuilder piramida= new StringBuilder();
for (int i=1;i<=n;i++) {
for (int j=0;j<n-i;j++) {
piramida.append(" ");
}
for (int k=0;k<2*i-1;k++) {
piramida.append(znak);
}
piramida.append("\n");
}
System.out.println(piramida);
}
}
public static void zad11(){
//Stwórz program, który przyjmie od użytkownika liczbę całkowitą i zwróci tę liczbę w odwrotnej kolejności.
// Na przykład, dla liczby 12345, wynik powinien wynosić 54321.
// Możesz ograniczyć program tylko do liczb dodatnich.
System.out.println("Podaj liczbę całkowitą: ");
Scanner skaner= new Scanner(System.in);
int liczba= skaner.nextInt();
int wynik=0;
if(liczba<0){
liczba*=-1;
while (liczba !=0) {
int cyfra = liczba % 10;
wynik=wynik*10+cyfra;
liczba/=10;
}
wynik*=-1;
}
else {
while (liczba !=0) {
int cyfra = liczba % 10;
wynik=wynik*10+cyfra;
liczba/=10;
}
}
System.out.print("Liczba w odwrotnej kolejności:"+wynik);
}
public static void main(String[] args) {
zad1();
zad2();
zad3();
zad4();
zad5();
zad6();
zad7();
zad8();
zad9();
zad10();
zad11();
//
}
} | //Napisz program, który przyjmuje jako wejście pojedynczy znak oraz liczbę całkowitą n. | import java.util.Scanner;
// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.
public class Main {
public static void zad1(){
//Napisz prostą aplikację kalkulatora tekstowego,
// która przyjmuje dwa liczby od użytkownika jako wejście
// i wykonuje podstawowe operacje matematyczne (dodawanie, odejmowanie, mnożenie, dzielenie).
// Wyświetl wyniki na ekranie.
System.out.print("Podaj pierwszą liczbę: ");
Scanner scanner = new Scanner(System.in);
double l1 = scanner.nextDouble();
System.out.print("Podaj drugą liczbę: ");
double l2 = scanner.nextDouble();
System.out.println("Wynik dodawania: " + (l1+l2));
System.out.println("Wynik odejmowania: " + (l1-l2));
System.out.println("Wynik mnożenia: " + (l1*l2));
System.out.println("Wynik dzielenia: " + (l1/l2));
}
public static void zad2(){
//Napisz program, który wczytuje ze standardowego wejścia dwa łańcuchy znaków,
// a następnie wypisuje je w kolejnych wierszach na standardowym wyjściu.
System.out.print("Podaj pierwszy łańcuch znaków:");
Scanner scanner =new Scanner(System.in);
String z1 = scanner.nextLine();
System.out.print("Podaj drugi łańcuch znaków:");
String z2 = scanner.nextLine();
System.out.println(z1);
System.out.println(z2);
}
public static void zad3(){
//Napisz program, który wczytuje ze standardowego wejścia cztery liczby wymierne,
// a następnie wypisuje ich sumę na standardowym wyjściu.
double suma=0;
for(int i=1;i<5;i++) {
System.out.println("Podaj liczbę wymierną nr" + i + ":");
Scanner scanner = new Scanner(System.in);
double liczba = scanner.nextDouble();
suma+=liczba;
}
System.out.println("Suma czterech liczb wynosi: "+suma);
}
public static void zad4(){
//Napisz program, który przyjmuje trzy liczby całkowite jako argumenty
// i zwraca największą z nich. Zastosuj instrukcje warunkowe do porównania liczb.
System.out.println("Podaj pierwszą liczbę całkowitą: ");
Scanner scanner = new Scanner(System.in);
int l1 = scanner.nextInt();
System.out.println("Podaj drugą liczbę całkowitą: ");
int l2 = scanner.nextInt();
System.out.println("Podaj trzecią liczbę całkowitą: ");
int l3 = scanner.nextInt();
if(l1>l2 && l1>l3){
System.out.println("Liczba "+ l1 + " jest największa");
}
else if(l3>l1 && l3>l2){
System.out.println("Liczba "+ l3 + " jest największa");
}
else{
System.out.println("Liczba "+ l2 + " jest największa");
}
}
public static void zad5(){
//Napisz program, który na podstawie podanego jako argument numeru dnia tygodnia (od 1 do 7) wypisze nazwę tego dnia tygodnia.
// Dla przykładu, jeżeli użytkownik poda liczbę 1, program powinien wypisać “Poniedziałek”.
// Jeżeli podana liczba nie jest z zakresu od 1 do 7,
// program powinien wyświetlić komunikat “Niepoprawny numer dnia tygodnia”.
System.out.println("Podaj numer dnia tygodnia z zakresu 1-7: ");
Scanner skaner = new Scanner(System.in);
int dzien = skaner.nextInt();
switch(dzien){
case 1:
System.out.println("Poniedziałek");
break;
case 2:
System.out.println("Wtorek");
break;
case 3:
System.out.println("Środa");
break;
case 4:
System.out.println("Czwartek");
break;
case 5:
System.out.println("PIĄTEK");
break;
case 6:
System.out.println("Sobota");
break;
case 7:
System.out.println("Niedziela");
break;
default:
System.out.println("Niepoprawny numer dnia tygodnia");
}
}
public static void zad6(){
//Napisz program, który będzie sprawdzał, czy podany rok jest rokiem przestępnym.
// Rok jest przestępny, jeśli jest podzielny przez 4, ale nie jest podzielny przez 100,
// chyba że jest podzielny przez 400
System.out.println("Podaj rok: ");
Scanner skaner = new Scanner(System.in);
int rok = skaner.nextInt();
if(rok%100==0){
if (rok % 400 == 0) {
System.out.println("Podany rok jest przestępny.");
}
else{
System.out.println("Podany rok nie jest przestępny.");
}
}
else if(rok%4==0){
System.out.println("Podany rok jest przestępny.");
}
else{
System.out.println("Podany rok nie jest przestępny.");
}
}
public static void zad7(){
//Napisz program, który oblicza sumę cyfr dowolnej wprowadzonej liczby.
// Program powinien akceptować liczbę jako input od użytkownika.
System.out.print("Podaj liczbę: ");
Scanner skaner= new Scanner(System.in);
int liczba = skaner.nextInt();
int suma =0;
int cyfra=liczba;
while (cyfra !=0) {
suma+= cyfra%10;
cyfra/=10;
}
System.out.println("Suma cyfr liczby "+liczba+" wynosi: "+suma);
}
public static void zad8(){
//Napisz program, który tworzy tablicę jednowymiarową 10 liczb całkowitych,
// a następnie wyświetla je w konsoli w porządku odwrotnym do wprowadzenia.
int[] tablica = new int[10];
Scanner scanner=new Scanner(System.in);
// Wprowadzenie liczb do tablicy
for (int i=0;i<10;i++) {
System.out.print("Podaj liczbę " +(i+1)+ ": ");
tablica[i] =scanner.nextInt();
}
System.out.println("Liczby w odwrotnej kolejności:");
for (int i=9;i>=0;i--) {
System.out.printf(tablica[i]+",");
}
}
public static void zad9(){
//Napisz program, który przyjmuje napis jako wejście
// i wypisuje wszystkie znaki znajdujące się na parzystych indeksach napisu, używając metody charAt.
System.out.print("Podaj napis: ");
Scanner scanner = new Scanner(System.in);
String napis =scanner.nextLine();
System.out.println("Znaki na parzystych indeksach:");
for (int i=0;i<napis.length();i+=2) {
char znak= napis.charAt(i);
System.out.printf(znak+",");
}
}
public static void zad10(){
//Napisz program, <SUF>
// Używając klasy StringBuilder, zbuduj i wypisz piramidę o wysokości n,
// gdzie każdy poziom piramidy składa się z podanego znaku.
System.out.print("Podaj znak: ");
Scanner scanner = new Scanner(System.in);
char znak = scanner.next().charAt(0);
System.out.print("Podaj wysokość piramidy (liczba całkowita): ");
int n = scanner.nextInt();
if (n<=0) {
System.out.println("Wysokość piramidy musi być liczbą dodatnią.");
} else {
StringBuilder piramida= new StringBuilder();
for (int i=1;i<=n;i++) {
for (int j=0;j<n-i;j++) {
piramida.append(" ");
}
for (int k=0;k<2*i-1;k++) {
piramida.append(znak);
}
piramida.append("\n");
}
System.out.println(piramida);
}
}
public static void zad11(){
//Stwórz program, który przyjmie od użytkownika liczbę całkowitą i zwróci tę liczbę w odwrotnej kolejności.
// Na przykład, dla liczby 12345, wynik powinien wynosić 54321.
// Możesz ograniczyć program tylko do liczb dodatnich.
System.out.println("Podaj liczbę całkowitą: ");
Scanner skaner= new Scanner(System.in);
int liczba= skaner.nextInt();
int wynik=0;
if(liczba<0){
liczba*=-1;
while (liczba !=0) {
int cyfra = liczba % 10;
wynik=wynik*10+cyfra;
liczba/=10;
}
wynik*=-1;
}
else {
while (liczba !=0) {
int cyfra = liczba % 10;
wynik=wynik*10+cyfra;
liczba/=10;
}
}
System.out.print("Liczba w odwrotnej kolejności:"+wynik);
}
public static void main(String[] args) {
zad1();
zad2();
zad3();
zad4();
zad5();
zad6();
zad7();
zad8();
zad9();
zad10();
zad11();
//
}
} | t |
9386_0 | Kronos1993/pracainz | 258 | PracaInz_v01/src/edu/util/PasswordUtils.java | package edu.util;
import com.lambdaworks.crypto.SCryptUtil;
public class PasswordUtils {
/*
* Metoda koduje haslo, ktore w bazie danych przechowywane jest w formie niejawnej,
* jezeli uzytkownik wpisze haslo to nawet administrator czy autor kodu, ktory ma dostep
* do bazy danych nie moze hasla podejzec, po przechowywana jest tam jego zakodowana forma.
* Sprawdzenie hasla polega na zakodowaniu podanego hasla i porownania ich zakodowanych wersji.
*/
public static String hashPassword(String originalPassword) {
return SCryptUtil.scrypt(originalPassword, 16, 16, 16);
}
public static boolean isPasswordMatch(String password, String passwordHashed) {
return SCryptUtil.check(password, passwordHashed);
}
}
| /*
* Metoda koduje haslo, ktore w bazie danych przechowywane jest w formie niejawnej,
* jezeli uzytkownik wpisze haslo to nawet administrator czy autor kodu, ktory ma dostep
* do bazy danych nie moze hasla podejzec, po przechowywana jest tam jego zakodowana forma.
* Sprawdzenie hasla polega na zakodowaniu podanego hasla i porownania ich zakodowanych wersji.
*/ | package edu.util;
import com.lambdaworks.crypto.SCryptUtil;
public class PasswordUtils {
/*
* Metoda koduje haslo, <SUF>*/
public static String hashPassword(String originalPassword) {
return SCryptUtil.scrypt(originalPassword, 16, 16, 16);
}
public static boolean isPasswordMatch(String password, String passwordHashed) {
return SCryptUtil.check(password, passwordHashed);
}
}
| t |
4534_0 | KryniuPL/Library_managment_system | 1,064 | src/main/java/com/library/model/User.java | package com.library.model;
import com.library.config.LibrarySetupConfig;
import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.NotEmpty;
import javax.persistence.*;
import java.util.*;
/**
* Odwzorowuje użytkownika z bazy danych
*/
@Entity
public class User implements Observer {
private Long userID;
@NotEmpty(message = "*Pole imię nie może być puste")
private String firstname;
@NotEmpty(message = "*Pole nazwisko nie może być puste")
private String surname;
@NotEmpty(message = "*Pole login nie może być puste")
private String username;
@NotEmpty(message = "*Pole hasło nie może być puste")
private String password;
@Email(message = "*Podaj prawidłowy adres e-mail")
@NotEmpty(message = "*Pole e-mail nie może być puste")
private String email;
private int active;
private Set<Role> roles = new HashSet<>(0);
private Stack<String> notes = new Stack<>();
public String getNote() {
if(!notes.empty())
return notes.pop();
else
return null;
}
public void setNote(String note) {
this.notes.push(note);
}
public void clearNotifications(){
this.notes = new Stack<>();
}
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Long getUserID() {
return userID;
}
public void setUserID(Long userID) {
this.userID = userID;
}
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getSurname() {
return surname;
}
public void setSurname(String surname) {
this.surname = surname;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public int getActive() {
return active;
}
public void setActive(int active) {
this.active = active;
}
@ManyToMany(cascade = CascadeType.ALL)
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
/**
* Ustawia notkę użytkownika w odpowiedzi na zmianę statusu BookBorrow
*
* @param o obiekt Observable
* @param arg argument przekazywany przez notify Observable
*/
@Override
public void update(Observable o, Object arg) {
String msg;
Object[] status = (Object[])arg;
Book book = (Book)status[LibrarySetupConfig.OBJECT];
if ((int)status[LibrarySetupConfig.COMPARISON_RESULT] == LibrarySetupConfig.TERM_REACHED) {
msg = "Termin przekroczony o " + Math.abs((int) status[LibrarySetupConfig.DAYS_BETWEEN]) + "dni!\n" +
"Dotyczy: " + book.getName() + " " + book.getAuthor();
}
else {
msg ="Zostało " + Math.abs((int) status[LibrarySetupConfig.DAYS_BETWEEN]) + " dni!\n" +
"Dotyczy: " + book.getName() + " " + book.getAuthor();
}
this.setNote(msg);
}
}
| /**
* Odwzorowuje użytkownika z bazy danych
*/ | package com.library.model;
import com.library.config.LibrarySetupConfig;
import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.NotEmpty;
import javax.persistence.*;
import java.util.*;
/**
* Odwzorowuje użytkownika z <SUF>*/
@Entity
public class User implements Observer {
private Long userID;
@NotEmpty(message = "*Pole imię nie może być puste")
private String firstname;
@NotEmpty(message = "*Pole nazwisko nie może być puste")
private String surname;
@NotEmpty(message = "*Pole login nie może być puste")
private String username;
@NotEmpty(message = "*Pole hasło nie może być puste")
private String password;
@Email(message = "*Podaj prawidłowy adres e-mail")
@NotEmpty(message = "*Pole e-mail nie może być puste")
private String email;
private int active;
private Set<Role> roles = new HashSet<>(0);
private Stack<String> notes = new Stack<>();
public String getNote() {
if(!notes.empty())
return notes.pop();
else
return null;
}
public void setNote(String note) {
this.notes.push(note);
}
public void clearNotifications(){
this.notes = new Stack<>();
}
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Long getUserID() {
return userID;
}
public void setUserID(Long userID) {
this.userID = userID;
}
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getSurname() {
return surname;
}
public void setSurname(String surname) {
this.surname = surname;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public int getActive() {
return active;
}
public void setActive(int active) {
this.active = active;
}
@ManyToMany(cascade = CascadeType.ALL)
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
/**
* Ustawia notkę użytkownika w odpowiedzi na zmianę statusu BookBorrow
*
* @param o obiekt Observable
* @param arg argument przekazywany przez notify Observable
*/
@Override
public void update(Observable o, Object arg) {
String msg;
Object[] status = (Object[])arg;
Book book = (Book)status[LibrarySetupConfig.OBJECT];
if ((int)status[LibrarySetupConfig.COMPARISON_RESULT] == LibrarySetupConfig.TERM_REACHED) {
msg = "Termin przekroczony o " + Math.abs((int) status[LibrarySetupConfig.DAYS_BETWEEN]) + "dni!\n" +
"Dotyczy: " + book.getName() + " " + book.getAuthor();
}
else {
msg ="Zostało " + Math.abs((int) status[LibrarySetupConfig.DAYS_BETWEEN]) + " dni!\n" +
"Dotyczy: " + book.getName() + " " + book.getAuthor();
}
this.setNote(msg);
}
}
| t |
6307_2 | KrystianOg/Ludo-Legends | 3,127 | src/entities/counters/Counter.java | package entities.counters;
import entities.Entity;
import players.PositionOnMap;
import entities.ui.Tile;
import entities.HUD.UltimateBar;
import ludogame.Handler;
import states.SettingState;
import java.awt.*;
import java.awt.image.BufferedImage;
public abstract class Counter extends Entity {
public static final int DEFAULT_WIDTH=41,
DEFAULT_HEIGHT=78;
protected double SCALE;
//
private final float basex;
private final float basey;
//
protected PositionOnMap pos;
protected double directionx,directiony;
protected boolean cisinbase, cfinished;
protected final Rectangle hitbox;
private boolean moving;
private boolean reseting;
private boolean won;
private PositionOnMap bufferedPosition;
//cos do umiejetnosci
protected boolean killable; //czy może być zbity
protected boolean canKill; //czy może zbijąć
private boolean beaten; //czy był zbity - do odrodzenia
protected boolean vulnerable; //czy ogień go zbija
//Ultimate bar
protected boolean ultBar;
protected UltimateBar ultimateBar=null;
protected boolean ultimateAbility=false;
//
//
protected BufferedImage counterColor;
//animacja
protected int ANIM_TICKS=(int)(0.37* SettingState.FPS);
private int tickcount=0;
protected int moved=0;
protected int tilesMoved=0;
public Counter(Handler handler, float x, float y,BufferedImage counterColor) {
super(handler,x, y,DEFAULT_WIDTH,DEFAULT_HEIGHT);
this.counterColor=counterColor;
basex=x;
basey=y;
hitbox=new Rectangle((int)x, (int)y,DEFAULT_WIDTH,DEFAULT_HEIGHT);
beaten=false;
cisinbase=true;
cfinished=false;
SCALE=1;
moving =false;
won=false;
}
public void tick(){
if(ultimateBar!=null)
ultimateBar.tick();
if(moving) {
moveLogic();
}
if(reseting){
resetLogic();
}
}
private void moveLogic(){
if(!won) {
if (cisinbase) {
if (tickcount == 0) {
Tile tempTile = handler.getTile(handler.getPlayer().getStartingPos());
handler.getLoadingScreen().setPlay("move");
directionx = (tempTile.getX() + 4 - x) / ANIM_TICKS;
directiony = (tempTile.getY() - 48 - y) / ANIM_TICKS;
tickcount++;
} else if (tickcount > 0 && tickcount < ANIM_TICKS) {
x += directionx;
y += directiony;
tickcount++;
} else if (tickcount == ANIM_TICKS) {
Tile tempTile = handler.getTile(handler.getPlayer().getStartingPos());
x = tempTile.getX() + 4;
y = tempTile.getY() - 48;
hitbox.x = (int) x;
hitbox.y = (int) y;
cisinbase = false;
tickcount = 0;
moving = false;
tilesMoved=0;
pos = new PositionOnMap(handler.getPlayer().getStartingPos());
bufferedPosition = getNextPosition();
handler.setCounterOnTile(pos, this);
handler.getTimer().resetTimer();
handler.getDice().setRolled(false);
if(handler.getPlayer().getRollsLeft()==0)
handler.getPlayer().setRollsLeft(1);
handler.getPlayer().setIsinbase(false);
handler.getGameState().setRenderOrder();
}
} else {
if (tickcount == 0) {
handler.removeCounterFromTile(pos, this);
if (ultimateAbility)
counterLogic();
handler.getLoadingScreen().setPlay("move");
renderBig();
directionx = (handler.getTile(bufferedPosition).getX() + 4 - x) / ANIM_TICKS;
directiony = (handler.getTile(bufferedPosition).getY() - 48 - y) / ANIM_TICKS;
tickcount++;
} else if (tickcount > 0 && tickcount < ANIM_TICKS) {
x += directionx;
y += directiony;
tickcount++;
} else if (tickcount == ANIM_TICKS) {
x = handler.getTile(bufferedPosition).getX() + 4;
y = handler.getTile(bufferedPosition).getY() - 48;
tickcount = 0;
handler.removeCounterFromTile(pos, this);
pos = bufferedPosition;
handler.getPlayer().addPoint();
moved++;
tilesMoved++;
bufferedPosition = getNextPosition();
if ((moved != handler.getRoll())&&!won)
handler.setCounterOnTile(pos, this);
handler.getGameState().setRenderOrder();
if ((moved == handler.getRoll())||won) {
moving = false;
hitbox.x = (int) x;
hitbox.y = (int) y;
handler.setCounterOnTile(pos, this);
handler.getDice().setRolled(false);
handler.getGameState().setRenderOrder();
moved = 0;
if (handler.getPlayer().getRollsLeft() == 0)
handler.setTurnof();
}
}
}
}
else {
handler.setTurnof();
handler.getPlayer().setRollsLeft(1);
moving=false;
handler.getDice().setRolled(false);
handler.getTimer().resetTimer();
if(handler.getPlayer().getClass().getName()=="players.Bot")
handler.getPlayer().setBotClicked();
}
}
private void resetLogic(){
if (tickcount == 0) {
directionx = (basex - x) / (ANIM_TICKS*2);
directiony = (basey - y) / (ANIM_TICKS*2);
tickcount++;
renderBig();
handler.getGameState().getPlayerByColor(counterColor).addDeath();
cisinbase = true;
handler.getGameState().setRenderOrder();
} else if (tickcount > 0 && tickcount < ANIM_TICKS*2) {
x += directionx;
y += directiony;
tickcount++;
} else if (tickcount == ANIM_TICKS*2) {
x = basex;
y = basey;
hitbox.x=(int)x;
hitbox.y=(int)y;
beaten=true;
cfinished=false;
tickcount = 0;
reseting=false;
pos = handler.getPlayer().getStartingPos();
//handler.getTimer().resetTimer();
//handler.getDice().setRolled(false);
}
}
protected PositionOnMap getNextPosition(){
if(handler.getDice().getRoll()>0) {
if (pos.arr == handler.getPlayer().getEndingPos().arr && pos.tile == handler.getPlayer().getEndingPos().tile&&tilesMoved>49) {
if (ultBar)
this.ultimateBar.setCanBeLoaded(false);
return new PositionOnMap(handler.getTurnOf() + 1, 0);
} else if (pos.tile == 51)
return new PositionOnMap(0);
else if (pos.arr > 0 && pos.tile == 5) {
won = true;
ultimateAbility = false;
System.out.println("WON");
return new PositionOnMap(pos.arr, pos.tile);
} else
return new PositionOnMap(pos.arr, pos.tile + 1);
}
//do "cofanie"
else if(handler.getDice().getRoll()==0)
return new PositionOnMap(pos.arr, pos.tile);
else{
if(pos.tile==0)
return new PositionOnMap(51);
else
return new PositionOnMap(pos.arr, pos.tile - 1);
}
}
public boolean isInbase() {
return cisinbase;
}
protected void renderWasKilled(Graphics g){
//g.drawImage(Assets.);
}
protected abstract void counterLogic();
//true jeśli wraca do bazy, false jeśli nie
public abstract boolean ifStepped();
public boolean hasUltBar(){
return this.ultBar;
}
public boolean isVulnerable(){
return this.vulnerable;
}
public void setMoving(boolean moving){
this.moving=moving;
}
public boolean isMoving(){
return this.moving;
}
public boolean isKillable(){
return this.killable;
}
public void renderUltBar(Graphics g){
if(ultimateBar!=null)
ultimateBar.render(g);
}
public boolean isClicked(){
return this.hitbox.contains(handler.getMouseClickX(),handler.getMouseClickY());
}
public void resetToBase(){
reseting=true;
moving=false;
cisinbase=true;
handler.getGameState().addToReset(this);
}
public boolean getMoving(){
return this.moving;
}
public boolean getReseting(){
return this.reseting;
}
public BufferedImage getCounterColor(){
return this.counterColor;
}
public int getBaseX(){
return (int)this.basex;
}
public int getBaseY(){
return (int)this.basey;
}
public boolean canKill(){
return this.canKill;
}
public void useUltimateAbility(){
this.ultimateAbility=true;
}
public void setUltimateAbility(boolean ult){
this.ultimateAbility=ult;
}
public boolean isBeaten(){
return this.beaten;
}
public void renderSmall(float shiftX,float shiftY){
if(SCALE==1) {
SCALE = 0.65;
hitbox.setSize((int)(hitbox.width*SCALE),(int)(hitbox.height*SCALE));
}
x=shiftX+4;
y=shiftY-48;
hitbox.setLocation((int)x,(int)y);
}
public void renderBig(float x,float y){
SCALE=1;
hitbox.setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
this.x=x;
this.y=y;
hitbox.setLocation((int)x,(int)y);
}
public void renderBig(){
SCALE=1;
hitbox.setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
}
public UltimateBar getUltimateBar(){
return this.ultimateBar;
}
public boolean getWon(){
return this.won;
}
} | //czy może zbijąć | package entities.counters;
import entities.Entity;
import players.PositionOnMap;
import entities.ui.Tile;
import entities.HUD.UltimateBar;
import ludogame.Handler;
import states.SettingState;
import java.awt.*;
import java.awt.image.BufferedImage;
public abstract class Counter extends Entity {
public static final int DEFAULT_WIDTH=41,
DEFAULT_HEIGHT=78;
protected double SCALE;
//
private final float basex;
private final float basey;
//
protected PositionOnMap pos;
protected double directionx,directiony;
protected boolean cisinbase, cfinished;
protected final Rectangle hitbox;
private boolean moving;
private boolean reseting;
private boolean won;
private PositionOnMap bufferedPosition;
//cos do umiejetnosci
protected boolean killable; //czy może być zbity
protected boolean canKill; //czy może <SUF>
private boolean beaten; //czy był zbity - do odrodzenia
protected boolean vulnerable; //czy ogień go zbija
//Ultimate bar
protected boolean ultBar;
protected UltimateBar ultimateBar=null;
protected boolean ultimateAbility=false;
//
//
protected BufferedImage counterColor;
//animacja
protected int ANIM_TICKS=(int)(0.37* SettingState.FPS);
private int tickcount=0;
protected int moved=0;
protected int tilesMoved=0;
public Counter(Handler handler, float x, float y,BufferedImage counterColor) {
super(handler,x, y,DEFAULT_WIDTH,DEFAULT_HEIGHT);
this.counterColor=counterColor;
basex=x;
basey=y;
hitbox=new Rectangle((int)x, (int)y,DEFAULT_WIDTH,DEFAULT_HEIGHT);
beaten=false;
cisinbase=true;
cfinished=false;
SCALE=1;
moving =false;
won=false;
}
public void tick(){
if(ultimateBar!=null)
ultimateBar.tick();
if(moving) {
moveLogic();
}
if(reseting){
resetLogic();
}
}
private void moveLogic(){
if(!won) {
if (cisinbase) {
if (tickcount == 0) {
Tile tempTile = handler.getTile(handler.getPlayer().getStartingPos());
handler.getLoadingScreen().setPlay("move");
directionx = (tempTile.getX() + 4 - x) / ANIM_TICKS;
directiony = (tempTile.getY() - 48 - y) / ANIM_TICKS;
tickcount++;
} else if (tickcount > 0 && tickcount < ANIM_TICKS) {
x += directionx;
y += directiony;
tickcount++;
} else if (tickcount == ANIM_TICKS) {
Tile tempTile = handler.getTile(handler.getPlayer().getStartingPos());
x = tempTile.getX() + 4;
y = tempTile.getY() - 48;
hitbox.x = (int) x;
hitbox.y = (int) y;
cisinbase = false;
tickcount = 0;
moving = false;
tilesMoved=0;
pos = new PositionOnMap(handler.getPlayer().getStartingPos());
bufferedPosition = getNextPosition();
handler.setCounterOnTile(pos, this);
handler.getTimer().resetTimer();
handler.getDice().setRolled(false);
if(handler.getPlayer().getRollsLeft()==0)
handler.getPlayer().setRollsLeft(1);
handler.getPlayer().setIsinbase(false);
handler.getGameState().setRenderOrder();
}
} else {
if (tickcount == 0) {
handler.removeCounterFromTile(pos, this);
if (ultimateAbility)
counterLogic();
handler.getLoadingScreen().setPlay("move");
renderBig();
directionx = (handler.getTile(bufferedPosition).getX() + 4 - x) / ANIM_TICKS;
directiony = (handler.getTile(bufferedPosition).getY() - 48 - y) / ANIM_TICKS;
tickcount++;
} else if (tickcount > 0 && tickcount < ANIM_TICKS) {
x += directionx;
y += directiony;
tickcount++;
} else if (tickcount == ANIM_TICKS) {
x = handler.getTile(bufferedPosition).getX() + 4;
y = handler.getTile(bufferedPosition).getY() - 48;
tickcount = 0;
handler.removeCounterFromTile(pos, this);
pos = bufferedPosition;
handler.getPlayer().addPoint();
moved++;
tilesMoved++;
bufferedPosition = getNextPosition();
if ((moved != handler.getRoll())&&!won)
handler.setCounterOnTile(pos, this);
handler.getGameState().setRenderOrder();
if ((moved == handler.getRoll())||won) {
moving = false;
hitbox.x = (int) x;
hitbox.y = (int) y;
handler.setCounterOnTile(pos, this);
handler.getDice().setRolled(false);
handler.getGameState().setRenderOrder();
moved = 0;
if (handler.getPlayer().getRollsLeft() == 0)
handler.setTurnof();
}
}
}
}
else {
handler.setTurnof();
handler.getPlayer().setRollsLeft(1);
moving=false;
handler.getDice().setRolled(false);
handler.getTimer().resetTimer();
if(handler.getPlayer().getClass().getName()=="players.Bot")
handler.getPlayer().setBotClicked();
}
}
private void resetLogic(){
if (tickcount == 0) {
directionx = (basex - x) / (ANIM_TICKS*2);
directiony = (basey - y) / (ANIM_TICKS*2);
tickcount++;
renderBig();
handler.getGameState().getPlayerByColor(counterColor).addDeath();
cisinbase = true;
handler.getGameState().setRenderOrder();
} else if (tickcount > 0 && tickcount < ANIM_TICKS*2) {
x += directionx;
y += directiony;
tickcount++;
} else if (tickcount == ANIM_TICKS*2) {
x = basex;
y = basey;
hitbox.x=(int)x;
hitbox.y=(int)y;
beaten=true;
cfinished=false;
tickcount = 0;
reseting=false;
pos = handler.getPlayer().getStartingPos();
//handler.getTimer().resetTimer();
//handler.getDice().setRolled(false);
}
}
protected PositionOnMap getNextPosition(){
if(handler.getDice().getRoll()>0) {
if (pos.arr == handler.getPlayer().getEndingPos().arr && pos.tile == handler.getPlayer().getEndingPos().tile&&tilesMoved>49) {
if (ultBar)
this.ultimateBar.setCanBeLoaded(false);
return new PositionOnMap(handler.getTurnOf() + 1, 0);
} else if (pos.tile == 51)
return new PositionOnMap(0);
else if (pos.arr > 0 && pos.tile == 5) {
won = true;
ultimateAbility = false;
System.out.println("WON");
return new PositionOnMap(pos.arr, pos.tile);
} else
return new PositionOnMap(pos.arr, pos.tile + 1);
}
//do "cofanie"
else if(handler.getDice().getRoll()==0)
return new PositionOnMap(pos.arr, pos.tile);
else{
if(pos.tile==0)
return new PositionOnMap(51);
else
return new PositionOnMap(pos.arr, pos.tile - 1);
}
}
public boolean isInbase() {
return cisinbase;
}
protected void renderWasKilled(Graphics g){
//g.drawImage(Assets.);
}
protected abstract void counterLogic();
//true jeśli wraca do bazy, false jeśli nie
public abstract boolean ifStepped();
public boolean hasUltBar(){
return this.ultBar;
}
public boolean isVulnerable(){
return this.vulnerable;
}
public void setMoving(boolean moving){
this.moving=moving;
}
public boolean isMoving(){
return this.moving;
}
public boolean isKillable(){
return this.killable;
}
public void renderUltBar(Graphics g){
if(ultimateBar!=null)
ultimateBar.render(g);
}
public boolean isClicked(){
return this.hitbox.contains(handler.getMouseClickX(),handler.getMouseClickY());
}
public void resetToBase(){
reseting=true;
moving=false;
cisinbase=true;
handler.getGameState().addToReset(this);
}
public boolean getMoving(){
return this.moving;
}
public boolean getReseting(){
return this.reseting;
}
public BufferedImage getCounterColor(){
return this.counterColor;
}
public int getBaseX(){
return (int)this.basex;
}
public int getBaseY(){
return (int)this.basey;
}
public boolean canKill(){
return this.canKill;
}
public void useUltimateAbility(){
this.ultimateAbility=true;
}
public void setUltimateAbility(boolean ult){
this.ultimateAbility=ult;
}
public boolean isBeaten(){
return this.beaten;
}
public void renderSmall(float shiftX,float shiftY){
if(SCALE==1) {
SCALE = 0.65;
hitbox.setSize((int)(hitbox.width*SCALE),(int)(hitbox.height*SCALE));
}
x=shiftX+4;
y=shiftY-48;
hitbox.setLocation((int)x,(int)y);
}
public void renderBig(float x,float y){
SCALE=1;
hitbox.setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
this.x=x;
this.y=y;
hitbox.setLocation((int)x,(int)y);
}
public void renderBig(){
SCALE=1;
hitbox.setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
}
public UltimateBar getUltimateBar(){
return this.ultimateBar;
}
public boolean getWon(){
return this.won;
}
} | t |
5138_1 | KrzysztofT/rozkladpkp-android | 1,199 | src/org/tyszecki/rozkladpkp/ExternalDelayFetcher.java | package org.tyszecki.rozkladpkp;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.HashMap;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import android.os.AsyncTask;
import android.text.TextUtils;
import android.text.format.Time;
public class ExternalDelayFetcher {
private static HashMap<String, Integer> delays = new HashMap<String, Integer>();
private static Time lastUpdate = null;
public static interface ExternalDelayFetcherCallback{
void ready(HashMap<String, Integer> delays, boolean cached);
}
static boolean isUpToDate()
{
if(lastUpdate == null)
{
lastUpdate = new Time();
lastUpdate.setToNow();
}
//Nie aktualizujmy za często.
long umi = lastUpdate.toMillis(false);
Time current = new Time();
current.setToNow();
long nmi = current.toMillis(false);
return !(delays.isEmpty() || nmi-umi < 1000*60*3);
}
static HashMap<String, Integer> getDelays()
{
return delays;
}
static void requestUpdate(final ExternalDelayFetcherCallback callback)
{
class DealyTask extends AsyncTask<Void, Void, Void>{
@Override
protected Void doInBackground(Void... arg0) {
//Prosty skrypt w pythonie parsuje stronę PR i wysyła mi wyniki.
//To lepsze niż parsowanie bezpośrednio w aplikacji:
//- W Pythonie można to napisać łatwiej,
//- Jeśli PR coś zmienią w formacie danych, wystarczy zmiana skryptu żeby działała ta aplikacja
//- Mogę dodawać do skryptu dane o opóźnieniach z innych źródeł
String url = "http://opoznienia.appspot.com";
DefaultHttpClient client = new DefaultHttpClient();
HttpGet request = new HttpGet(url);
request.addHeader("Content-Type", "application/x-www-form-urlencoded");
HttpResponse response = null;
InputStream inputStream = null;
try {
response = client.execute(request);
HttpEntity entity = response.getEntity();
inputStream = entity.getContent();
} catch (Exception e) {
e.printStackTrace();
}
ByteArrayOutputStream content = new ByteArrayOutputStream();
byte[] sBuffer = new byte[512];
// Read response into a buffered stream
int readBytes = 0;
try {
while ((readBytes = inputStream.read(sBuffer)) != -1) {
content.write(sBuffer, 0, readBytes);
}
} catch (Exception e) {
e.printStackTrace();
}
// Return result from buffered stream
TextUtils.StringSplitter lineSplitter = new TextUtils.SimpleStringSplitter('\n');
lineSplitter.setString(new String(content.toByteArray()));
delays.clear();
for(String s : lineSplitter)
{
int col = s.indexOf(':');
try{
if(col > -1)
delays.put(s.substring(0, col), Integer.parseInt(s.substring(col+1)));
}catch(Exception e)
{
return null;
}
}
return null;
}
protected void onPostExecute(Void result) {
callback.ready(delays, false);
}
}
new DealyTask().execute(null,null,null);
}
}
| //Prosty skrypt w pythonie parsuje stronę PR i wysyła mi wyniki. | package org.tyszecki.rozkladpkp;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.HashMap;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import android.os.AsyncTask;
import android.text.TextUtils;
import android.text.format.Time;
public class ExternalDelayFetcher {
private static HashMap<String, Integer> delays = new HashMap<String, Integer>();
private static Time lastUpdate = null;
public static interface ExternalDelayFetcherCallback{
void ready(HashMap<String, Integer> delays, boolean cached);
}
static boolean isUpToDate()
{
if(lastUpdate == null)
{
lastUpdate = new Time();
lastUpdate.setToNow();
}
//Nie aktualizujmy za często.
long umi = lastUpdate.toMillis(false);
Time current = new Time();
current.setToNow();
long nmi = current.toMillis(false);
return !(delays.isEmpty() || nmi-umi < 1000*60*3);
}
static HashMap<String, Integer> getDelays()
{
return delays;
}
static void requestUpdate(final ExternalDelayFetcherCallback callback)
{
class DealyTask extends AsyncTask<Void, Void, Void>{
@Override
protected Void doInBackground(Void... arg0) {
//Prosty skrypt <SUF>
//To lepsze niż parsowanie bezpośrednio w aplikacji:
//- W Pythonie można to napisać łatwiej,
//- Jeśli PR coś zmienią w formacie danych, wystarczy zmiana skryptu żeby działała ta aplikacja
//- Mogę dodawać do skryptu dane o opóźnieniach z innych źródeł
String url = "http://opoznienia.appspot.com";
DefaultHttpClient client = new DefaultHttpClient();
HttpGet request = new HttpGet(url);
request.addHeader("Content-Type", "application/x-www-form-urlencoded");
HttpResponse response = null;
InputStream inputStream = null;
try {
response = client.execute(request);
HttpEntity entity = response.getEntity();
inputStream = entity.getContent();
} catch (Exception e) {
e.printStackTrace();
}
ByteArrayOutputStream content = new ByteArrayOutputStream();
byte[] sBuffer = new byte[512];
// Read response into a buffered stream
int readBytes = 0;
try {
while ((readBytes = inputStream.read(sBuffer)) != -1) {
content.write(sBuffer, 0, readBytes);
}
} catch (Exception e) {
e.printStackTrace();
}
// Return result from buffered stream
TextUtils.StringSplitter lineSplitter = new TextUtils.SimpleStringSplitter('\n');
lineSplitter.setString(new String(content.toByteArray()));
delays.clear();
for(String s : lineSplitter)
{
int col = s.indexOf(':');
try{
if(col > -1)
delays.put(s.substring(0, col), Integer.parseInt(s.substring(col+1)));
}catch(Exception e)
{
return null;
}
}
return null;
}
protected void onPostExecute(Void result) {
callback.ready(delays, false);
}
}
new DealyTask().execute(null,null,null);
}
}
| t |
3208_3 | KubaRajewski/Kurs | 716 | src/dalsze/podstawy/daty/data/urodzenia/Main.java | package dalsze.podstawy.daty.data.urodzenia;
//Poproś program aby zapytal Cię o datę Twojego urodzenia
//- jeśli podałeś datę późniejszą niż dziś to niech program rzuci
// błędem: InvalidBirthDateException
//- program wypisuje ile dni żyjesz już
//- program wypisuje ile już miesiecy żyjesz
//- program wypisuje już ile lat żyjesz
//- program wypisuje w który dzień tygodnia się urodziłeś
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
public class Main {
public static void main(String[] args) {
String data = "14-10-199d5";
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("dd-MM-yyyy");
LocalDate birthDate = null;
try {
birthDate = LocalDate.parse(data, dtf);
czyDataJestWPrzyszlosci(birthDate);
System.out.println(ileDniZyje(birthDate));
System.out.println(ileMiesiecyZyje(birthDate));
System.out.println(wJakimDniuSieUrodzil(birthDate));
} catch (DateTimeParseException e) {
System.out.println(e.getMessage());
System.out.println("Nie mozna sparsowac daty");
} catch (InvalidBirthDateException e) {
System.out.println(e.getMessage());
System.out.println("Nie mozesz podac daty w przyszlosci");
}
}
public static void czyDataJestWPrzyszlosci(LocalDate date) {
if (date.isAfter(LocalDate.now())) {
throw new InvalidBirthDateException("data nie moze byc pozniejsza niz dzisiaj");
}
}
public static long ileDniZyje(LocalDate date) {
return ChronoUnit.DAYS.between(LocalDate.now(), date);
}
public static long ileMiesiecyZyje(LocalDate date) {
return ChronoUnit.MONTHS.between(LocalDate.now(), date);
}
public static long ileLatZyje(LocalDate date) {
return ChronoUnit.YEARS.between(LocalDate.now(), date);
}
public static DayOfWeek wJakimDniuSieUrodzil(LocalDate date) {
return date.getDayOfWeek();
}
}
| //- program wypisuje ile już miesiecy żyjesz | package dalsze.podstawy.daty.data.urodzenia;
//Poproś program aby zapytal Cię o datę Twojego urodzenia
//- jeśli podałeś datę późniejszą niż dziś to niech program rzuci
// błędem: InvalidBirthDateException
//- program wypisuje ile dni żyjesz już
//- program <SUF>
//- program wypisuje już ile lat żyjesz
//- program wypisuje w który dzień tygodnia się urodziłeś
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
public class Main {
public static void main(String[] args) {
String data = "14-10-199d5";
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("dd-MM-yyyy");
LocalDate birthDate = null;
try {
birthDate = LocalDate.parse(data, dtf);
czyDataJestWPrzyszlosci(birthDate);
System.out.println(ileDniZyje(birthDate));
System.out.println(ileMiesiecyZyje(birthDate));
System.out.println(wJakimDniuSieUrodzil(birthDate));
} catch (DateTimeParseException e) {
System.out.println(e.getMessage());
System.out.println("Nie mozna sparsowac daty");
} catch (InvalidBirthDateException e) {
System.out.println(e.getMessage());
System.out.println("Nie mozesz podac daty w przyszlosci");
}
}
public static void czyDataJestWPrzyszlosci(LocalDate date) {
if (date.isAfter(LocalDate.now())) {
throw new InvalidBirthDateException("data nie moze byc pozniejsza niz dzisiaj");
}
}
public static long ileDniZyje(LocalDate date) {
return ChronoUnit.DAYS.between(LocalDate.now(), date);
}
public static long ileMiesiecyZyje(LocalDate date) {
return ChronoUnit.MONTHS.between(LocalDate.now(), date);
}
public static long ileLatZyje(LocalDate date) {
return ChronoUnit.YEARS.between(LocalDate.now(), date);
}
public static DayOfWeek wJakimDniuSieUrodzil(LocalDate date) {
return date.getDayOfWeek();
}
}
| t |
9027_2 | KubaZ/amu_automata_2011 | 890 | daut-re/src/main/java/pl/edu/amu/wmi/daut/re/RegexpUtilities.java | package pl.edu.amu.wmi.daut.re;
import java.util.Stack;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import pl.edu.amu.wmi.daut.base.AutomatonSpecification;
/**
* Klasa z pomocniczymi funkcjami operującymi na wyrażeniach regularnych.
*/
public class RegexpUtilities {
protected RegexpUtilities() { throw new UnsupportedOperationException(); }
/**
* Metoda, która z drzewa operatorów robi automat.
*/
public static AutomatonSpecification createAutomatonFromOperatorTree(RegexpOperatorTree tree) {
//przejdź przez drzewo stanów metodą post-order, przy pomocy dwóch stosów.
Stack<RegexpOperatorTree> child = new Stack<RegexpOperatorTree>();
Stack<RegexpOperatorTree> parent = new Stack<RegexpOperatorTree>();
child.push(tree);
while (!child.empty()) {
RegexpOperatorTree current = child.peek();
parent.push(current);
child.pop();
for (RegexpOperatorTree subTree : current.getSubtrees())
child.push(subTree);
}
//na stosie "parent" mamy teraz wierzchołki w porządku post-order!
//w porządku post-order chodzi o to, że zawsze zaczynamy od nieodwiedzonych liści
//i idziemy powoli w kierunku korzenia drzewa.
//utwórz mapę poddrzew na automaty przez nich utworzone.
Map<RegexpOperatorTree, AutomatonSpecification> map = new HashMap<RegexpOperatorTree,
AutomatonSpecification>();
while (!parent.empty()) {
RegexpOperatorTree current = parent.peek();
//utwórz listę automatów utworzonych przez synów wierzchołka.
List<AutomatonSpecification> arguments = new ArrayList<AutomatonSpecification>();
for (RegexpOperatorTree subTree : current.getSubtrees()) {
//nie będzie tutaj odwołania do nieistniejących kluczy ze
//wzgl. na charakter porządku post-order. jeśli wystąpi tutaj
//exception, to znaczy, że źle zaimplementowaliśmy coś wcześniej.
AutomatonSpecification subTreeAutomaton = map.get(subTree);
arguments.add(subTreeAutomaton);
}
//utwórz automat, którego argumentami są automaty wszystkich synów.
AutomatonSpecification currentAutomaton = current.getRoot().createAutomaton(
arguments);
//zapamiętaj automat dla danego wierzchołka. ponieważ liście się
//wykonają "najpierw", to nadchodzący po tym rodzice tych liści
//będą mieli pełną informację o automatach utworzonych przez
//swoich synów...
map.put(current, currentAutomaton);
parent.pop();
//usunęliśmy właśnie wierzchołek-korzeń - zostaliśmy z pustym stosem,
//możemy zwrócić automat.
if (parent.empty())
return currentAutomaton;
}
throw new IllegalStateException();
}
}
| //przejdź przez drzewo stanów metodą post-order, przy pomocy dwóch stosów. | package pl.edu.amu.wmi.daut.re;
import java.util.Stack;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import pl.edu.amu.wmi.daut.base.AutomatonSpecification;
/**
* Klasa z pomocniczymi funkcjami operującymi na wyrażeniach regularnych.
*/
public class RegexpUtilities {
protected RegexpUtilities() { throw new UnsupportedOperationException(); }
/**
* Metoda, która z drzewa operatorów robi automat.
*/
public static AutomatonSpecification createAutomatonFromOperatorTree(RegexpOperatorTree tree) {
//przejdź przez <SUF>
Stack<RegexpOperatorTree> child = new Stack<RegexpOperatorTree>();
Stack<RegexpOperatorTree> parent = new Stack<RegexpOperatorTree>();
child.push(tree);
while (!child.empty()) {
RegexpOperatorTree current = child.peek();
parent.push(current);
child.pop();
for (RegexpOperatorTree subTree : current.getSubtrees())
child.push(subTree);
}
//na stosie "parent" mamy teraz wierzchołki w porządku post-order!
//w porządku post-order chodzi o to, że zawsze zaczynamy od nieodwiedzonych liści
//i idziemy powoli w kierunku korzenia drzewa.
//utwórz mapę poddrzew na automaty przez nich utworzone.
Map<RegexpOperatorTree, AutomatonSpecification> map = new HashMap<RegexpOperatorTree,
AutomatonSpecification>();
while (!parent.empty()) {
RegexpOperatorTree current = parent.peek();
//utwórz listę automatów utworzonych przez synów wierzchołka.
List<AutomatonSpecification> arguments = new ArrayList<AutomatonSpecification>();
for (RegexpOperatorTree subTree : current.getSubtrees()) {
//nie będzie tutaj odwołania do nieistniejących kluczy ze
//wzgl. na charakter porządku post-order. jeśli wystąpi tutaj
//exception, to znaczy, że źle zaimplementowaliśmy coś wcześniej.
AutomatonSpecification subTreeAutomaton = map.get(subTree);
arguments.add(subTreeAutomaton);
}
//utwórz automat, którego argumentami są automaty wszystkich synów.
AutomatonSpecification currentAutomaton = current.getRoot().createAutomaton(
arguments);
//zapamiętaj automat dla danego wierzchołka. ponieważ liście się
//wykonają "najpierw", to nadchodzący po tym rodzice tych liści
//będą mieli pełną informację o automatach utworzonych przez
//swoich synów...
map.put(current, currentAutomaton);
parent.pop();
//usunęliśmy właśnie wierzchołek-korzeń - zostaliśmy z pustym stosem,
//możemy zwrócić automat.
if (parent.empty())
return currentAutomaton;
}
throw new IllegalStateException();
}
}
| t |
5109_0 | Kurczaczek21/Object-oriented-Programming | 297 | src/LAB_6/examples/G0.java | package LAB_6.examples;
import javax.swing.*;
public class G0 {
public static void createAndShowGUI() {
JFrame jf = new JFrame("My First Frame");
jf.pack();
jf.setVisible(true);
}
public static void main(String[] args) {
System.out.println("Before");
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() { createAndShowGUI(); }
});
System.out.println("After");
}
}
/*
Uwagi:
Proszę sprawdzić co zrobić aby:
- Aplikacja wyświetlała się na środku ekranu.
- Cyfra 0 (oraz inne w polu z wynikiem) były pogrubione, czcionką Arial i z dosunięciem do prawej strony.
- Pole z wynikiem nie powinno być edytowalne.
- Zaś cała aplikacja ma mieć stały rozmiar i użytkownik nie może go zmieniać.
*/ | /*
Uwagi:
Proszę sprawdzić co zrobić aby:
- Aplikacja wyświetlała się na środku ekranu.
- Cyfra 0 (oraz inne w polu z wynikiem) były pogrubione, czcionką Arial i z dosunięciem do prawej strony.
- Pole z wynikiem nie powinno być edytowalne.
- Zaś cała aplikacja ma mieć stały rozmiar i użytkownik nie może go zmieniać.
*/ | package LAB_6.examples;
import javax.swing.*;
public class G0 {
public static void createAndShowGUI() {
JFrame jf = new JFrame("My First Frame");
jf.pack();
jf.setVisible(true);
}
public static void main(String[] args) {
System.out.println("Before");
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() { createAndShowGUI(); }
});
System.out.println("After");
}
}
/*
Uwagi:
<SUF>*/ | t |
9874_2 | Kwi4t3k/programowanie_java | 690 | kolos1_2022/src/FoodProduct.java | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.DoubleStream;
public class FoodProduct extends Product{
Map<String, List<Double>> pricesPerProvince = new HashMap<>();
public FoodProduct(String name, Map<String, List<Double>> pricesPerProvince) {
super(name);
this.pricesPerProvince = pricesPerProvince;
}
@Override
public double getPrice(int year, int month) {
return pricesPerProvince.keySet().stream()
.map(key -> getPrice(year, month, key)) // weźmiemy nazwy województw i wyciągniemy z nich ceny dla każdego
.flatMapToDouble(DoubleStream::of) // zamiana na listę doubli
.average() // średnia
.orElse(0); // jeśli się nie uda zrobić średniej to zwraca 0
}
public static FoodProduct fromCsv(Path path){
try {
BufferedReader bufferedReader = new BufferedReader(new FileReader(path.toFile()));
String productName = bufferedReader.readLine();
bufferedReader.readLine(); // skip miesięcy
String currentLine;
Map<String, List<Double>> pricesPerProvince = new HashMap<>();
while ((currentLine = bufferedReader.readLine()) != null){
String[] parts = currentLine.split(";", -1);
String province = parts[0];
List<Double> pricePerDate = List.of(parts).subList(1, parts.length - 1).stream()
.map(string -> string.replaceAll(",", ".")) // zamiany "," z pliku na "." crtl + spacja robi strzałkę
.map(Double::parseDouble)
.toList(); //zamiana listy partsów na double
pricesPerProvince.put(province, pricePerDate); // wszystkie województwa i wszystkie ich ceny
}
return new FoodProduct(productName, pricesPerProvince);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public double getPrice(int year, int month, String province){
var prices = pricesPerProvince.get(province);
int index = (year - 2010) * 12 + month - 1; //zmiana roku i miesiąca w indeks tabeli
return prices.get(index);
}
}
| // jeśli się nie uda zrobić średniej to zwraca 0 | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.DoubleStream;
public class FoodProduct extends Product{
Map<String, List<Double>> pricesPerProvince = new HashMap<>();
public FoodProduct(String name, Map<String, List<Double>> pricesPerProvince) {
super(name);
this.pricesPerProvince = pricesPerProvince;
}
@Override
public double getPrice(int year, int month) {
return pricesPerProvince.keySet().stream()
.map(key -> getPrice(year, month, key)) // weźmiemy nazwy województw i wyciągniemy z nich ceny dla każdego
.flatMapToDouble(DoubleStream::of) // zamiana na listę doubli
.average() // średnia
.orElse(0); // jeśli się <SUF>
}
public static FoodProduct fromCsv(Path path){
try {
BufferedReader bufferedReader = new BufferedReader(new FileReader(path.toFile()));
String productName = bufferedReader.readLine();
bufferedReader.readLine(); // skip miesięcy
String currentLine;
Map<String, List<Double>> pricesPerProvince = new HashMap<>();
while ((currentLine = bufferedReader.readLine()) != null){
String[] parts = currentLine.split(";", -1);
String province = parts[0];
List<Double> pricePerDate = List.of(parts).subList(1, parts.length - 1).stream()
.map(string -> string.replaceAll(",", ".")) // zamiany "," z pliku na "." crtl + spacja robi strzałkę
.map(Double::parseDouble)
.toList(); //zamiana listy partsów na double
pricesPerProvince.put(province, pricePerDate); // wszystkie województwa i wszystkie ich ceny
}
return new FoodProduct(productName, pricesPerProvince);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public double getPrice(int year, int month, String province){
var prices = pricesPerProvince.get(province);
int index = (year - 2010) * 12 + month - 1; //zmiana roku i miesiąca w indeks tabeli
return prices.get(index);
}
}
| t |
2795_3 | LOpuchlik/pjatk | 732 | MAS/MAS_MP1_s16478/src/Manager.java | import java.time.LocalDate;
public class Manager extends RegularEmployee { // klasa Manager nie musi implementować Serializable, bo dzidziczy go z nadklasy RegularEmployee, która go implementuje
private static final long serialVersionUID = 1L;
private static double maxBonus = 5000d; // atrybut klasowy - wszyscy managerowie mogą mieć maksymalnie bonus tej wysokości
private double managersBaseSalary; // atrybut obiektowy - każdy manager może mieć inną bazę, typ prymityeny - nie sprawdzam czy null
private double percentBonus; // opcjonalny i obiektowy, z ograniczeniem (przyjmuje wartości od 0 do 1)
public Manager(String name, String surname, LocalDate birthDate, String contactData, double managersBaseSalary) {
super(name, surname, birthDate, contactData);
this.managersBaseSalary = managersBaseSalary;
}
public static double getMaxBonus() {
return maxBonus;
}
public static void setMaxBonus(double maxBonus) {
Manager.maxBonus = maxBonus;
}
public double getBonus() {
return percentBonus;
}
public void setBonus(double percentBonus) throws Exception {
if(percentBonus < 0.0 || percentBonus > 1.0) {
throw new Exception("Percent bonus has to be in range between 0 and 1");
}
this.percentBonus = percentBonus;
}
// przeciążanie metod, inaczej się liczy gdy nie ma bonusa i gdy jest bonus (wtedy jest parametr)
public double countSalary() {
return managersBaseSalary;
}
public double countSalary(double percentBonus) {
return managersBaseSalary + (percentBonus * maxBonus);
}
@Override // przesłonięcie metody toString()
public String toString() {
String description = "";
description += "Name and Surname:\t\t|\t" + getName() + " " + getSurname() + " (MANAGER)";
description += "\nDate of Birth (age):\t|\t" + getBirthDate() + " (" + getAgeInYears() + " years old)";
description += "\nContact Information:\t|\t" + getContactData();
if(getFormalEducation().size() > 0)
description += "\nFormal Education: \t\t|\t" + getFormalEducation().toString() + "\n";
else
description += "\nFormal Education: \t\t|\tNo formal education to show\n";
return description;
}
}
| // opcjonalny i obiektowy, z ograniczeniem (przyjmuje wartości od 0 do 1) | import java.time.LocalDate;
public class Manager extends RegularEmployee { // klasa Manager nie musi implementować Serializable, bo dzidziczy go z nadklasy RegularEmployee, która go implementuje
private static final long serialVersionUID = 1L;
private static double maxBonus = 5000d; // atrybut klasowy - wszyscy managerowie mogą mieć maksymalnie bonus tej wysokości
private double managersBaseSalary; // atrybut obiektowy - każdy manager może mieć inną bazę, typ prymityeny - nie sprawdzam czy null
private double percentBonus; // opcjonalny i <SUF>
public Manager(String name, String surname, LocalDate birthDate, String contactData, double managersBaseSalary) {
super(name, surname, birthDate, contactData);
this.managersBaseSalary = managersBaseSalary;
}
public static double getMaxBonus() {
return maxBonus;
}
public static void setMaxBonus(double maxBonus) {
Manager.maxBonus = maxBonus;
}
public double getBonus() {
return percentBonus;
}
public void setBonus(double percentBonus) throws Exception {
if(percentBonus < 0.0 || percentBonus > 1.0) {
throw new Exception("Percent bonus has to be in range between 0 and 1");
}
this.percentBonus = percentBonus;
}
// przeciążanie metod, inaczej się liczy gdy nie ma bonusa i gdy jest bonus (wtedy jest parametr)
public double countSalary() {
return managersBaseSalary;
}
public double countSalary(double percentBonus) {
return managersBaseSalary + (percentBonus * maxBonus);
}
@Override // przesłonięcie metody toString()
public String toString() {
String description = "";
description += "Name and Surname:\t\t|\t" + getName() + " " + getSurname() + " (MANAGER)";
description += "\nDate of Birth (age):\t|\t" + getBirthDate() + " (" + getAgeInYears() + " years old)";
description += "\nContact Information:\t|\t" + getContactData();
if(getFormalEducation().size() > 0)
description += "\nFormal Education: \t\t|\t" + getFormalEducation().toString() + "\n";
else
description += "\nFormal Education: \t\t|\tNo formal education to show\n";
return description;
}
}
| t |
8162_2 | LaneyBlack/Practices-UTP | 446 | UTP6_RA_S24382/src/UTP31/Main1.java | /**
*
* @author Reut Anton S24382
*
*/
package UTP31;
import java.util.stream.Collectors;
import java.util.*; /*<-- niezbędne importy */
public class Main1 {
public static void main(String[] args) {
// Lista destynacji: port_wylotu port_przylotu cena_EUR
List<String> dest = Arrays.asList(
"bleble bleble 2000",
"WAW HAV 1200",
"xxx yyy 789",
"WAW DPS 2000",
"WAW HKT 1000"
);
double ratePLNvsEUR = 4.30;
List<String> result = dest.stream().filter(element->element.startsWith("WAW")).map(element->{
String[] values = element.split(" ",3);
int price = Integer.parseInt(values[2]);
return "to "+values[1]+" - "+"price in PLN: " + (int)(price*ratePLNvsEUR);
}).collect(Collectors.toList() /*<-- lambda wyrażenie
* wyliczenie ceny przelotu w PLN
* i stworzenie wynikowego napisu
*/
);
/*<-- tu należy dopisać fragment
* przy czym nie wolno używać żadnych własnych klas, jak np. ListCreator
* ani też żadnych własnych interfejsów
* Podpowiedź: należy użyć strumieni
*/
for (String r : result) System.out.println(r);
}
}
| // Lista destynacji: port_wylotu port_przylotu cena_EUR | /**
*
* @author Reut Anton S24382
*
*/
package UTP31;
import java.util.stream.Collectors;
import java.util.*; /*<-- niezbędne importy */
public class Main1 {
public static void main(String[] args) {
// Lista destynacji: <SUF>
List<String> dest = Arrays.asList(
"bleble bleble 2000",
"WAW HAV 1200",
"xxx yyy 789",
"WAW DPS 2000",
"WAW HKT 1000"
);
double ratePLNvsEUR = 4.30;
List<String> result = dest.stream().filter(element->element.startsWith("WAW")).map(element->{
String[] values = element.split(" ",3);
int price = Integer.parseInt(values[2]);
return "to "+values[1]+" - "+"price in PLN: " + (int)(price*ratePLNvsEUR);
}).collect(Collectors.toList() /*<-- lambda wyrażenie
* wyliczenie ceny przelotu w PLN
* i stworzenie wynikowego napisu
*/
);
/*<-- tu należy dopisać fragment
* przy czym nie wolno używać żadnych własnych klas, jak np. ListCreator
* ani też żadnych własnych interfejsów
* Podpowiedź: należy użyć strumieni
*/
for (String r : result) System.out.println(r);
}
}
| t |
8366_1 | Latropos/MyEvolutionProject | 3,780 | MyEvolutionProject/src/Evolution/RectangularMap.java | package Evolution;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import java.util.*;
import static java.lang.Math.toIntExact;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import org.json.simple.parser.ParseException;
public class RectangularMap {
private final Vector2d startOfTheMap = new Vector2d(0,0);
private static final String filePath = "Evolution/parameters.json";
public final int width;
public final int height;
int moveEnergy = 1;
int plantEnergy = 1;
int numberOfGrass = 8;
double jungleRatio = 0.25;
protected final Vector2d endOfTheMap;
public final Jungle jungle;
public List<Animal> animalsList = new ArrayList<>();
protected Map<Vector2d, Grass> grassMap = new LinkedHashMap<>();
public RectangularMap(int width, int height) {
this.width = width;
this.height = height;
this.endOfTheMap = new Vector2d(width - 1, height - 1);
try (FileReader reader = new FileReader(ClassLoader.getSystemResource(filePath).getFile())) {
JSONParser jsonParser = new JSONParser();
JSONObject jsonObject = (JSONObject) jsonParser.parse(reader);
this.moveEnergy = toIntExact((long) jsonObject.get("moveEnergy"));
this.plantEnergy = toIntExact((long) jsonObject.get("plantEnergy"));
this.numberOfGrass = toIntExact((long) jsonObject.get("initialNumberOfGrass"));;
String s = (String) jsonObject.get("jungleRatio");
this.jungleRatio = Double.parseDouble(s);
this.jungleRatio = Math.sqrt(this.jungleRatio);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
}
int jungleWidth = (int) Math.ceil(width *jungleRatio);
int jungleHeight = (int) Math.ceil(height *jungleRatio);
this.jungle = new Jungle(jungleWidth, jungleHeight);
for (int i = 0; i < this.numberOfGrass; i++) {
addGrass();
}
}
public void addGrass(){
//add in Jungle;
if (!jungleIsFull()) {
boolean toBeContinued = true;
int forceToStop = 3000; //usprawnienie dla naprawdę dużej planszy
while (toBeContinued) {
toBeContinued = false;
Vector2d pos = new Vector2d(getRandomNumberInRange(0, width - 1), getRandomNumberInRange(0, height - 1));
Grass insertGrass = new Grass(pos);
if (grassMap.containsKey(insertGrass.getPosition())) {
toBeContinued = true;
forceToStop -= 1;
}
if (animalObjectAt(insertGrass.getPosition()).size() >= 1) {
toBeContinued = true;
forceToStop -= 1;
} else if (!pos.precedes(jungle.endOfTheJungle) && pos.follows(jungle.startOfTheJungle)) {
toBeContinued = true;
forceToStop -= 1;
} else this.grassMap.put(insertGrass.getPosition(), insertGrass);
if (forceToStop <= 0) break;
}
}
//add in step;
if (!stepIsFull()) {
boolean toBeContinued = true;
int forceToStop = 3000;
while (toBeContinued) {
toBeContinued = false;
Vector2d pos = new Vector2d(getRandomNumberInRange(0, width - 1), getRandomNumberInRange(0, height - 1));
Grass insertGrass = new Grass(pos);
if (grassMap.containsKey(insertGrass.getPosition())) {
toBeContinued = true;
forceToStop -= 1;
}
if (animalObjectAt(insertGrass.getPosition()).size() >= 1) {
toBeContinued = true;
forceToStop -= 1;
} else if (pos.precedes(jungle.endOfTheJungle) && pos.follows(jungle.startOfTheJungle)) {
toBeContinued = true;
forceToStop -= 1;
} else this.grassMap.put(insertGrass.getPosition(), insertGrass);
if (forceToStop <= 0) return;
}
}
}
public boolean jungleIsFull(){
for (int i = 0; i<jungle.width; i++)
for (int j = 0; j<jungle.height; j++){
if ( !isOccupied(new Vector2d(i,j))) return false;
}
return true;
}
public boolean stepIsFull(){
for (int i = jungle.width; i<width; i++)
for (int j = 0; j<jungle.height; j++){
if ( !isOccupied(new Vector2d(i,j))) return false;
}
for (int i = 0; i<width; i++)
for (int j = jungle.height; j<height; j++){
if ( isOccupied(new Vector2d(i,j))) return false;
}
return true;
}
private static int getRandomNumberInRange(int min, int max) {
if (min >= max) {
throw new IllegalArgumentException("max must be greater than min");
}
Random r = new Random();
return r.nextInt((max - min) + 1) + min;
}
public String toString(){
MapVisualizer mapVisualizer = new MapVisualizer(this);
StringBuilder builder = new StringBuilder();
builder.append(mapVisualizer.draw(this.startOfTheMap, this.endOfTheMap));
return builder.toString();
}
public boolean isOccupied(Vector2d position) {
for (int i=0; i<animalsList.size(); i++){
if (this.animalsList.get(i).getPosition().equals(position)) return true;
}
if (grassMap.containsKey(position)) return true;
return false;
}
public void place(Animal animal) {
this.animalsList.add(animal);
}
public Object objectAt(Vector2d position) {
for (int i=0; i<animalsList.size(); i++) {
if (this.animalsList.get(i).getPosition().equals(position)) return animalsList.get(i);
}
return (grassObjectAt(position));
}
public Grass grassObjectAt (Vector2d position){
if (this.grassMap.containsKey(position))
return this.grassMap.get(position);
return null;
}
public List<Animal> animalObjectAt (Vector2d position){
List<Animal> rivals = new ArrayList<>();
for (int i=0; i<animalsList.size(); i++) {
if (this.animalsList.get(i).getPosition().equals(position)) rivals.add(animalsList.get(i));
}
return rivals;
}
public List<Animal> strongAnimalObjectAt (Vector2d position){
List<Animal> rivals = new ArrayList<>();
for (int i=0; i<animalsList.size(); i++) {
if (this.animalsList.get(i).getPosition().equals(position) && this.animalsList.get(i).getEnergyDay()>=Animal.startEnergy/2) rivals.add(animalsList.get(i));
}
return rivals;
}
public void eatGrassAt (Vector2d position){
this.grassMap.remove(position);
List<Animal> rivals = strongAnimalObjectAt(position);
if (rivals.size() == 1) {rivals.get(0).energyDay += plantEnergy; return;}
double maxEnergyDay = 0;
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay()>maxEnergyDay) maxEnergyDay = rivals.get(i).getEnergyDay();
}
int animalsToShare = 0;
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == maxEnergyDay) animalsToShare += 1;
}
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == maxEnergyDay) rivals.get(i).energyDay += (plantEnergy/animalsToShare);
}
}
public void copulateAt(Vector2d position) {
List<Animal> rivals = animalObjectAt(position);
if (rivals.size() == 2) {makeChild(rivals.get(0),rivals.get(1)); return;}
double maxEnergyDay = 0;
int maxEnergyHolders = 0;
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay()>maxEnergyDay){
maxEnergyDay = rivals.get(i).getEnergyDay();
maxEnergyHolders = 1;
}
if (rivals.get(i).getEnergyDay()==maxEnergyDay)
maxEnergyHolders += 1;
}
Animal parent1 = null;
Animal parent2 = null;
if (maxEnergyHolders >= 2){
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == maxEnergyDay) {
if (parent1 == null) parent1 = rivals.get(i);
else {
parent2 = rivals.get(i);
makeChild(parent1,parent2);
return;
}
}
}
}
else {
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == maxEnergyDay) parent1 = rivals.get(i);
}
double secMaxEnergyDay = 0;
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() >= secMaxEnergyDay &&
rivals.get(i).getEnergyDay() < maxEnergyDay) secMaxEnergyDay = rivals.get(i).getEnergyDay();
}
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == secMaxEnergyDay) parent2 = rivals.get(i);
}
makeChild(parent1, parent2);
}
}
private void makeChild(Animal parent1, Animal parent2) {
int cut1 = getRandomNumberInRange(0,32);
int cut2 = getRandomNumberInRange(0,32);
if(cut1>cut2){
int t = cut2; cut2 = cut1; cut1 = t;
}
final MoveDirection [] genotype = new MoveDirection[32];
for (int i=0; i<cut1; i++)
genotype[i] = parent1.genotype[i];
for (int i=cut1; i<cut2; i++)
genotype[i] = parent2.genotype[i];
for (int i=cut2; i<32; i++)
genotype[i] = parent1.genotype[i];
parent1.energyDay = (parent1.energyDay * 3)/4;
parent2.energyDay = (parent2.energyDay * 3)/4;
parent1.noChildren += 1;
parent2.noChildren += 1;
Animal child = new Animal(this,parent1.getPosition().randomNeighbour(), genotype);
child.energyDay = parent1.energyDay/3 + parent2.energyDay/3;
child.repairGenotype();
return;
}
private void removingDead(){
for (int i=0; i<animalsList.size(); i++)
if(animalsList.get(i).getEnergyDay() <= 0) animalsList.remove(animalsList.get(i));
}
private void running() {
for (int i=0; i<animalsList.size(); i++)
animalsList.get(i).move();
}
private void eating(){
for (int i=0; i<animalsList.size(); i++)
animalsList.get(i).tryToEat();
}
private void copulating(){
List<Vector2d> places = new ArrayList<>();
for (int i=0; i<animalsList.size(); i++)
if(animalsList.get(i).tryToCopulate()) {
Vector2d place = animalsList.get(i).getPosition();
boolean newPlace = true;
for(int j=0; j<places.size(); j++){
if(places.get(j).equals(place)) newPlace = false;
}
if (newPlace) places.add(place);
}
for (int i =0; i<places.size(); i++){
copulateAt(places.get(i));
}
}
private void sleeping(){
for (int i=0; i<animalsList.size(); i++)
animalsList.get(i).energyDay -= moveEnergy;
}
public void anotherDay(){
removingDead();
running();
eating();
copulating();
sleeping();
addGrass();
}
}
| //usprawnienie dla naprawdę dużej planszy | package Evolution;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import java.util.*;
import static java.lang.Math.toIntExact;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import org.json.simple.parser.ParseException;
public class RectangularMap {
private final Vector2d startOfTheMap = new Vector2d(0,0);
private static final String filePath = "Evolution/parameters.json";
public final int width;
public final int height;
int moveEnergy = 1;
int plantEnergy = 1;
int numberOfGrass = 8;
double jungleRatio = 0.25;
protected final Vector2d endOfTheMap;
public final Jungle jungle;
public List<Animal> animalsList = new ArrayList<>();
protected Map<Vector2d, Grass> grassMap = new LinkedHashMap<>();
public RectangularMap(int width, int height) {
this.width = width;
this.height = height;
this.endOfTheMap = new Vector2d(width - 1, height - 1);
try (FileReader reader = new FileReader(ClassLoader.getSystemResource(filePath).getFile())) {
JSONParser jsonParser = new JSONParser();
JSONObject jsonObject = (JSONObject) jsonParser.parse(reader);
this.moveEnergy = toIntExact((long) jsonObject.get("moveEnergy"));
this.plantEnergy = toIntExact((long) jsonObject.get("plantEnergy"));
this.numberOfGrass = toIntExact((long) jsonObject.get("initialNumberOfGrass"));;
String s = (String) jsonObject.get("jungleRatio");
this.jungleRatio = Double.parseDouble(s);
this.jungleRatio = Math.sqrt(this.jungleRatio);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
}
int jungleWidth = (int) Math.ceil(width *jungleRatio);
int jungleHeight = (int) Math.ceil(height *jungleRatio);
this.jungle = new Jungle(jungleWidth, jungleHeight);
for (int i = 0; i < this.numberOfGrass; i++) {
addGrass();
}
}
public void addGrass(){
//add in Jungle;
if (!jungleIsFull()) {
boolean toBeContinued = true;
int forceToStop = 3000; //usprawnienie dla <SUF>
while (toBeContinued) {
toBeContinued = false;
Vector2d pos = new Vector2d(getRandomNumberInRange(0, width - 1), getRandomNumberInRange(0, height - 1));
Grass insertGrass = new Grass(pos);
if (grassMap.containsKey(insertGrass.getPosition())) {
toBeContinued = true;
forceToStop -= 1;
}
if (animalObjectAt(insertGrass.getPosition()).size() >= 1) {
toBeContinued = true;
forceToStop -= 1;
} else if (!pos.precedes(jungle.endOfTheJungle) && pos.follows(jungle.startOfTheJungle)) {
toBeContinued = true;
forceToStop -= 1;
} else this.grassMap.put(insertGrass.getPosition(), insertGrass);
if (forceToStop <= 0) break;
}
}
//add in step;
if (!stepIsFull()) {
boolean toBeContinued = true;
int forceToStop = 3000;
while (toBeContinued) {
toBeContinued = false;
Vector2d pos = new Vector2d(getRandomNumberInRange(0, width - 1), getRandomNumberInRange(0, height - 1));
Grass insertGrass = new Grass(pos);
if (grassMap.containsKey(insertGrass.getPosition())) {
toBeContinued = true;
forceToStop -= 1;
}
if (animalObjectAt(insertGrass.getPosition()).size() >= 1) {
toBeContinued = true;
forceToStop -= 1;
} else if (pos.precedes(jungle.endOfTheJungle) && pos.follows(jungle.startOfTheJungle)) {
toBeContinued = true;
forceToStop -= 1;
} else this.grassMap.put(insertGrass.getPosition(), insertGrass);
if (forceToStop <= 0) return;
}
}
}
public boolean jungleIsFull(){
for (int i = 0; i<jungle.width; i++)
for (int j = 0; j<jungle.height; j++){
if ( !isOccupied(new Vector2d(i,j))) return false;
}
return true;
}
public boolean stepIsFull(){
for (int i = jungle.width; i<width; i++)
for (int j = 0; j<jungle.height; j++){
if ( !isOccupied(new Vector2d(i,j))) return false;
}
for (int i = 0; i<width; i++)
for (int j = jungle.height; j<height; j++){
if ( isOccupied(new Vector2d(i,j))) return false;
}
return true;
}
private static int getRandomNumberInRange(int min, int max) {
if (min >= max) {
throw new IllegalArgumentException("max must be greater than min");
}
Random r = new Random();
return r.nextInt((max - min) + 1) + min;
}
public String toString(){
MapVisualizer mapVisualizer = new MapVisualizer(this);
StringBuilder builder = new StringBuilder();
builder.append(mapVisualizer.draw(this.startOfTheMap, this.endOfTheMap));
return builder.toString();
}
public boolean isOccupied(Vector2d position) {
for (int i=0; i<animalsList.size(); i++){
if (this.animalsList.get(i).getPosition().equals(position)) return true;
}
if (grassMap.containsKey(position)) return true;
return false;
}
public void place(Animal animal) {
this.animalsList.add(animal);
}
public Object objectAt(Vector2d position) {
for (int i=0; i<animalsList.size(); i++) {
if (this.animalsList.get(i).getPosition().equals(position)) return animalsList.get(i);
}
return (grassObjectAt(position));
}
public Grass grassObjectAt (Vector2d position){
if (this.grassMap.containsKey(position))
return this.grassMap.get(position);
return null;
}
public List<Animal> animalObjectAt (Vector2d position){
List<Animal> rivals = new ArrayList<>();
for (int i=0; i<animalsList.size(); i++) {
if (this.animalsList.get(i).getPosition().equals(position)) rivals.add(animalsList.get(i));
}
return rivals;
}
public List<Animal> strongAnimalObjectAt (Vector2d position){
List<Animal> rivals = new ArrayList<>();
for (int i=0; i<animalsList.size(); i++) {
if (this.animalsList.get(i).getPosition().equals(position) && this.animalsList.get(i).getEnergyDay()>=Animal.startEnergy/2) rivals.add(animalsList.get(i));
}
return rivals;
}
public void eatGrassAt (Vector2d position){
this.grassMap.remove(position);
List<Animal> rivals = strongAnimalObjectAt(position);
if (rivals.size() == 1) {rivals.get(0).energyDay += plantEnergy; return;}
double maxEnergyDay = 0;
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay()>maxEnergyDay) maxEnergyDay = rivals.get(i).getEnergyDay();
}
int animalsToShare = 0;
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == maxEnergyDay) animalsToShare += 1;
}
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == maxEnergyDay) rivals.get(i).energyDay += (plantEnergy/animalsToShare);
}
}
public void copulateAt(Vector2d position) {
List<Animal> rivals = animalObjectAt(position);
if (rivals.size() == 2) {makeChild(rivals.get(0),rivals.get(1)); return;}
double maxEnergyDay = 0;
int maxEnergyHolders = 0;
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay()>maxEnergyDay){
maxEnergyDay = rivals.get(i).getEnergyDay();
maxEnergyHolders = 1;
}
if (rivals.get(i).getEnergyDay()==maxEnergyDay)
maxEnergyHolders += 1;
}
Animal parent1 = null;
Animal parent2 = null;
if (maxEnergyHolders >= 2){
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == maxEnergyDay) {
if (parent1 == null) parent1 = rivals.get(i);
else {
parent2 = rivals.get(i);
makeChild(parent1,parent2);
return;
}
}
}
}
else {
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == maxEnergyDay) parent1 = rivals.get(i);
}
double secMaxEnergyDay = 0;
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() >= secMaxEnergyDay &&
rivals.get(i).getEnergyDay() < maxEnergyDay) secMaxEnergyDay = rivals.get(i).getEnergyDay();
}
for (int i=0; i<rivals.size(); i++){
if (rivals.get(i).getEnergyDay() == secMaxEnergyDay) parent2 = rivals.get(i);
}
makeChild(parent1, parent2);
}
}
private void makeChild(Animal parent1, Animal parent2) {
int cut1 = getRandomNumberInRange(0,32);
int cut2 = getRandomNumberInRange(0,32);
if(cut1>cut2){
int t = cut2; cut2 = cut1; cut1 = t;
}
final MoveDirection [] genotype = new MoveDirection[32];
for (int i=0; i<cut1; i++)
genotype[i] = parent1.genotype[i];
for (int i=cut1; i<cut2; i++)
genotype[i] = parent2.genotype[i];
for (int i=cut2; i<32; i++)
genotype[i] = parent1.genotype[i];
parent1.energyDay = (parent1.energyDay * 3)/4;
parent2.energyDay = (parent2.energyDay * 3)/4;
parent1.noChildren += 1;
parent2.noChildren += 1;
Animal child = new Animal(this,parent1.getPosition().randomNeighbour(), genotype);
child.energyDay = parent1.energyDay/3 + parent2.energyDay/3;
child.repairGenotype();
return;
}
private void removingDead(){
for (int i=0; i<animalsList.size(); i++)
if(animalsList.get(i).getEnergyDay() <= 0) animalsList.remove(animalsList.get(i));
}
private void running() {
for (int i=0; i<animalsList.size(); i++)
animalsList.get(i).move();
}
private void eating(){
for (int i=0; i<animalsList.size(); i++)
animalsList.get(i).tryToEat();
}
private void copulating(){
List<Vector2d> places = new ArrayList<>();
for (int i=0; i<animalsList.size(); i++)
if(animalsList.get(i).tryToCopulate()) {
Vector2d place = animalsList.get(i).getPosition();
boolean newPlace = true;
for(int j=0; j<places.size(); j++){
if(places.get(j).equals(place)) newPlace = false;
}
if (newPlace) places.add(place);
}
for (int i =0; i<places.size(); i++){
copulateAt(places.get(i));
}
}
private void sleeping(){
for (int i=0; i<animalsList.size(); i++)
animalsList.get(i).energyDay -= moveEnergy;
}
public void anotherDay(){
removingDead();
running();
eating();
copulating();
sleeping();
addGrass();
}
}
| t |
8288_9 | LukasMod/ElementaryJavaFX_LibraryProject | 1,165 | src/main/java/pl/my/library/datbase/models/Book.java | package pl.my.library.datbase.models;
import com.j256.ormlite.field.DataType;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;
import java.util.Date;
@DatabaseTable(tableName = "BOOKS")
public class Book implements BaseModel {
public static final String AUTHOR_ID = "AUTHOR_ID";
public static final String CATEGORY_ID = "CATEGORY_ID";
//bezparametrowy konstruktor Alt+Insert
public Book() {
}
// TWORZYMY POLE OBCE
@DatabaseField(generatedId = true)
private int id;
@DatabaseField(columnName = AUTHOR_ID, foreign = true, foreignAutoCreate = true, foreignAutoRefresh = true, canBeNull = false)
private Author author;
@DatabaseField(columnName = CATEGORY_ID, foreign = true, foreignAutoCreate = true, foreignAutoRefresh = true, canBeNull = false)
private Category category;
//utworzy się kolumna z nazwą author_id. Lepiej nazwąć jawną naze, aby uniknąć pomyłek
//foreignAutoCreate - pomagają w obsłudze
//foreignAutoRefresh - pomagają w obsłudze
@DatabaseField(columnName = "TITLE", canBeNull = false) //nigdy nie może być nullem
private String title;
// @DatabaseField(columnName = "DATE_RELEASE", dataType = DataType.DATE_STRING, format = "yyyy-MM-DD")
@DatabaseField(columnName = "RELEASE_DATE")
private Date releaseDate;
@DatabaseField(columnName = "ISBN") //unique = true, zawsze unikalne elementy
private String isbn;
@DatabaseField(columnName = "DESCRIPTION", dataType = DataType.LONG_STRING) //dla Stringów powyżej 256 znaków
private String description;
@DatabaseField(columnName = "RATING", width = 1)
//maksymalna ilość znaków (nie działa np. na sqlite, ale na h2 działa)
private int rating;
@DatabaseField(columnName = "ADDED_DATE")
private Date addedDate;
// @DatabaseField(columnName = "BORROWED", defaultValue = "false") //domyślna wartość
// private boolean borrowed;
//
// @DatabaseField(columnName = "PRICE")
// private double price;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public void setDescription(String description) {
this.description = description;
}
public String getIsbn() { return isbn; }
public void setIsbn(String isbn) { this.isbn = isbn; }
public Date getAddedDate() {
return addedDate;
}
public void setAddedDate(Date addedDate) {
this.addedDate = addedDate;
}
public Date getReleaseDate() {
return releaseDate;
}
public void setReleaseDate(Date releaseDate) {
this.releaseDate = releaseDate;
}
public int getRating() {
return rating;
}
public void setRating(int rating) {
this.rating = rating;
}
public Author getAuthor() {
return author;
}
public void setAuthor(Author author) {
this.author = author;
}
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
// public boolean isBorrowed() {
// return borrowed;
// }
//
// public void setBorrowed(boolean borrowed) {
// this.borrowed = borrowed;
// }
//
// public double getPrice() {
// return price;
// }
//
// public void setPrice(double price) {
// this.price = price;
// }
}
| //maksymalna ilość znaków (nie działa np. na sqlite, ale na h2 działa) | package pl.my.library.datbase.models;
import com.j256.ormlite.field.DataType;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;
import java.util.Date;
@DatabaseTable(tableName = "BOOKS")
public class Book implements BaseModel {
public static final String AUTHOR_ID = "AUTHOR_ID";
public static final String CATEGORY_ID = "CATEGORY_ID";
//bezparametrowy konstruktor Alt+Insert
public Book() {
}
// TWORZYMY POLE OBCE
@DatabaseField(generatedId = true)
private int id;
@DatabaseField(columnName = AUTHOR_ID, foreign = true, foreignAutoCreate = true, foreignAutoRefresh = true, canBeNull = false)
private Author author;
@DatabaseField(columnName = CATEGORY_ID, foreign = true, foreignAutoCreate = true, foreignAutoRefresh = true, canBeNull = false)
private Category category;
//utworzy się kolumna z nazwą author_id. Lepiej nazwąć jawną naze, aby uniknąć pomyłek
//foreignAutoCreate - pomagają w obsłudze
//foreignAutoRefresh - pomagają w obsłudze
@DatabaseField(columnName = "TITLE", canBeNull = false) //nigdy nie może być nullem
private String title;
// @DatabaseField(columnName = "DATE_RELEASE", dataType = DataType.DATE_STRING, format = "yyyy-MM-DD")
@DatabaseField(columnName = "RELEASE_DATE")
private Date releaseDate;
@DatabaseField(columnName = "ISBN") //unique = true, zawsze unikalne elementy
private String isbn;
@DatabaseField(columnName = "DESCRIPTION", dataType = DataType.LONG_STRING) //dla Stringów powyżej 256 znaków
private String description;
@DatabaseField(columnName = "RATING", width = 1)
//maksymalna ilość <SUF>
private int rating;
@DatabaseField(columnName = "ADDED_DATE")
private Date addedDate;
// @DatabaseField(columnName = "BORROWED", defaultValue = "false") //domyślna wartość
// private boolean borrowed;
//
// @DatabaseField(columnName = "PRICE")
// private double price;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public void setDescription(String description) {
this.description = description;
}
public String getIsbn() { return isbn; }
public void setIsbn(String isbn) { this.isbn = isbn; }
public Date getAddedDate() {
return addedDate;
}
public void setAddedDate(Date addedDate) {
this.addedDate = addedDate;
}
public Date getReleaseDate() {
return releaseDate;
}
public void setReleaseDate(Date releaseDate) {
this.releaseDate = releaseDate;
}
public int getRating() {
return rating;
}
public void setRating(int rating) {
this.rating = rating;
}
public Author getAuthor() {
return author;
}
public void setAuthor(Author author) {
this.author = author;
}
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
// public boolean isBorrowed() {
// return borrowed;
// }
//
// public void setBorrowed(boolean borrowed) {
// this.borrowed = borrowed;
// }
//
// public double getPrice() {
// return price;
// }
//
// public void setPrice(double price) {
// this.price = price;
// }
}
| t |
6131_5 | LukasMod/JavaElementaryApps | 712 | src/LambdaDemo2.java | class LambdaDemo2 {
public static void main(String[] args) {
//to wyrażenie lambda sprawdza czy jedna liczba jest czynnikiem drugiej
NumericTest isFactor = (n, d) -> (n % d) == 0;
if (isFactor.test(10, 2))
System.out.println("Liczba 2 jest czynnikiem liczby 10");
if (!isFactor.test(10, 3))
System.out.println("Liczba 3 nie jest czynniekiem liczby 10");
System.out.println();
//to wyrażenie lambda zwraca true, jeśli pierwszy argument jest mniejszy od drugiego
NumericTest lessThan = (n, m) -> (n < m);
if (lessThan.test(2, 10))
System.out.println("Liczba 2 jest mniejsza od liczby 10");
if (!lessThan.test(10, 2))
System.out.println("Liczba 10 nie jest mniejsza od liczby 2");
System.out.println();
//to wyraniżenie lambda zwraca true, jeśli wartości bezwzględne argumentów są sobie równe
NumericTest absEqual = (n, m) -> (n < 0 ? -n : n) == (m < 0 ? -m : m);
// '?' oznacza wyrażnie ? wart. jesli prawda : wart. jesli fałsz
if (absEqual.test(-4, 4))
System.out.println("Wartości bezwględne 4 i -4 są równe");
if (!absEqual.test(4, -5))
System.out.println("wartości bezględne 4 i -5 nie są równe");
System.out.println();
//Blokowe wyrażenie lambda znajdujące najmniejszy dodatni czynnik wartości typu int
NumericTest2 smallestF = (n) -> {
int result = 1;
//określa wartość bezwględną n
n = n < 0 ? -n : n;
for (int i = 2; i <= n / i; i++)
if ((n % i) == 0) {
result = i;
break;
}
return result;
}; //ważny dwukropek
System.out.println("Najmniejszym czynnikiem liczby 12 jest " + smallestF.func(12));
System.out.println("Najmniejszym czynnikiem liczby 9 jest " + smallestF.func(9));
}
}
| //określa wartość bezwględną n | class LambdaDemo2 {
public static void main(String[] args) {
//to wyrażenie lambda sprawdza czy jedna liczba jest czynnikiem drugiej
NumericTest isFactor = (n, d) -> (n % d) == 0;
if (isFactor.test(10, 2))
System.out.println("Liczba 2 jest czynnikiem liczby 10");
if (!isFactor.test(10, 3))
System.out.println("Liczba 3 nie jest czynniekiem liczby 10");
System.out.println();
//to wyrażenie lambda zwraca true, jeśli pierwszy argument jest mniejszy od drugiego
NumericTest lessThan = (n, m) -> (n < m);
if (lessThan.test(2, 10))
System.out.println("Liczba 2 jest mniejsza od liczby 10");
if (!lessThan.test(10, 2))
System.out.println("Liczba 10 nie jest mniejsza od liczby 2");
System.out.println();
//to wyraniżenie lambda zwraca true, jeśli wartości bezwzględne argumentów są sobie równe
NumericTest absEqual = (n, m) -> (n < 0 ? -n : n) == (m < 0 ? -m : m);
// '?' oznacza wyrażnie ? wart. jesli prawda : wart. jesli fałsz
if (absEqual.test(-4, 4))
System.out.println("Wartości bezwględne 4 i -4 są równe");
if (!absEqual.test(4, -5))
System.out.println("wartości bezględne 4 i -5 nie są równe");
System.out.println();
//Blokowe wyrażenie lambda znajdujące najmniejszy dodatni czynnik wartości typu int
NumericTest2 smallestF = (n) -> {
int result = 1;
//określa wartość <SUF>
n = n < 0 ? -n : n;
for (int i = 2; i <= n / i; i++)
if ((n % i) == 0) {
result = i;
break;
}
return result;
}; //ważny dwukropek
System.out.println("Najmniejszym czynnikiem liczby 12 jest " + smallestF.func(12));
System.out.println("Najmniejszym czynnikiem liczby 9 jest " + smallestF.func(9));
}
}
| t |
2778_0 | M0ng00se7169/AiSD | 1,012 | src/main/lists/ArrayList.java | package main.lists;
import main.iteration.ArrayIterator;
import main.iteration.Iterator;
public class ArrayList implements List {
// Domyslny rozmiar początkowy tablicy
private static final int DEFAULT_INITIAL_CAPACITY = 16;
private final int initialCapacity;
private Object[] array;
private int size;
public ArrayList() {
this(DEFAULT_INITIAL_CAPACITY);
}
public ArrayList(int initialCapacity) {
assert initialCapacity > 0 : "Początkowy rozmiar tablicy musi być dodatni";
this.initialCapacity = initialCapacity;
clear();
}
@Override
public Iterator iterator() {
return new ArrayIterator(array, 0, size);
}
@Override
public void insert(int index, Object value) throws IndexOutOfBoundsException {
assert value != null : "Nie można wstawiać wartości pustych";
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException();
}
ensureCapacity(size + 1);
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = value;
++size;
}
@Override
public void add(Object value) {
insert(size, value);
}
@Override
public Object delete(int index) throws IndexOutOfBoundsException {
checkOutOfBounds(index);
Object value = array[index];
int copyFromIndex = index + 1;
if (copyFromIndex < size) {
System.arraycopy(array, copyFromIndex, array, index, size - copyFromIndex);
}
array[--size] = null;
return value;
}
@Override
public boolean delete(Object value) {
int index = indexOf(value);
if (index != -1) {
delete(index);
return true;
}
return false;
}
@Override
public void clear() {
this.array = new Object[initialCapacity];
this.size = 0;
}
@Override
public Object set(int index, Object value) throws IndexOutOfBoundsException {
assert value != null : "wartość nie może być pusta";
checkOutOfBounds(index);
Object oldValue = array[index];
array[index] = value;
return oldValue;
}
@Override
public Object get(int index) throws IndexOutOfBoundsException {
checkOutOfBounds(index);
return array[index];
}
@Override
public int indexOf(Object value) {
assert value != null : "Wartość nie może być pusta";
for (int i = 0; i < size; i++) {
if (value.equals(array[i])) {
return i;
}
}
return -1;
}
@Override
public boolean contains(Object value) {
return indexOf(value) != -1;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size() == 0;
}
private void ensureCapacity(int capacity) {
assert capacity > 0 : "rozmiar musi być dodatni";
if (array.length < capacity) {
Object[] copy = new Object[capacity + capacity / 2];
System.arraycopy(array, 0, copy, 0, size);
array = copy;
}
}
private void checkOutOfBounds(int index) {
if (isOutOfBounds(index)) {
throw new IndexOutOfBoundsException();
}
}
private boolean isOutOfBounds(int index) {
return index < 0 || index >= size;
}
}
| // Domyslny rozmiar początkowy tablicy | package main.lists;
import main.iteration.ArrayIterator;
import main.iteration.Iterator;
public class ArrayList implements List {
// Domyslny rozmiar <SUF>
private static final int DEFAULT_INITIAL_CAPACITY = 16;
private final int initialCapacity;
private Object[] array;
private int size;
public ArrayList() {
this(DEFAULT_INITIAL_CAPACITY);
}
public ArrayList(int initialCapacity) {
assert initialCapacity > 0 : "Początkowy rozmiar tablicy musi być dodatni";
this.initialCapacity = initialCapacity;
clear();
}
@Override
public Iterator iterator() {
return new ArrayIterator(array, 0, size);
}
@Override
public void insert(int index, Object value) throws IndexOutOfBoundsException {
assert value != null : "Nie można wstawiać wartości pustych";
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException();
}
ensureCapacity(size + 1);
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = value;
++size;
}
@Override
public void add(Object value) {
insert(size, value);
}
@Override
public Object delete(int index) throws IndexOutOfBoundsException {
checkOutOfBounds(index);
Object value = array[index];
int copyFromIndex = index + 1;
if (copyFromIndex < size) {
System.arraycopy(array, copyFromIndex, array, index, size - copyFromIndex);
}
array[--size] = null;
return value;
}
@Override
public boolean delete(Object value) {
int index = indexOf(value);
if (index != -1) {
delete(index);
return true;
}
return false;
}
@Override
public void clear() {
this.array = new Object[initialCapacity];
this.size = 0;
}
@Override
public Object set(int index, Object value) throws IndexOutOfBoundsException {
assert value != null : "wartość nie może być pusta";
checkOutOfBounds(index);
Object oldValue = array[index];
array[index] = value;
return oldValue;
}
@Override
public Object get(int index) throws IndexOutOfBoundsException {
checkOutOfBounds(index);
return array[index];
}
@Override
public int indexOf(Object value) {
assert value != null : "Wartość nie może być pusta";
for (int i = 0; i < size; i++) {
if (value.equals(array[i])) {
return i;
}
}
return -1;
}
@Override
public boolean contains(Object value) {
return indexOf(value) != -1;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size() == 0;
}
private void ensureCapacity(int capacity) {
assert capacity > 0 : "rozmiar musi być dodatni";
if (array.length < capacity) {
Object[] copy = new Object[capacity + capacity / 2];
System.arraycopy(array, 0, copy, 0, size);
array = copy;
}
}
private void checkOutOfBounds(int index) {
if (isOutOfBounds(index)) {
throw new IndexOutOfBoundsException();
}
}
private boolean isOutOfBounds(int index) {
return index < 0 || index >= size;
}
}
| t |
5696_13 | MADWI/Widget_MAD | 2,207 | src/mad/widget/activities/PlanChangesActivity.java | package mad.widget.activities;
import java.util.ArrayList;
import mad.widget.R;
import mad.widget.connections.GetPlanChanges;
import mad.widget.connections.HttpConnect;
import mad.widget.models.ListViewAdapterPlanChanges;
import mad.widget.models.MessagePlanChanges;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.res.Resources;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;
/**
* Aktywnosc wyswietlajaca zmiany w planie w formie ListView
*
* @author Sebastian Swierczek
* @version 1.3.1
*/
public class PlanChangesActivity extends Activity {
/** Obiekt typu GetPlanChanges */
private final GetPlanChanges pars = new GetPlanChanges();
/**
* Zmienna do debuggowania.
*/
private static final String TAG = "PlanChangesActivity";
/**
* Obiekt klasy Resources, odwolujacy sie do wartosci z pliku
* res/strings.xml
*/
private Resources res;
/**
* Obiekt ArrayList zawierajacy obiekty klasy MessagePlanChanges, gdzie
* wyswietlane beda zmiany w planie
*/
private ArrayList<MessagePlanChanges> news = new ArrayList<MessagePlanChanges>();
/** Obiekt ListViewAdapterPlanChanges */
private ListViewAdapterPlanChanges adapter;
/** Obiekt ListView */
private ListView lvPlanChanges;
/** Obiekt ProgressDialog */
private ProgressDialog pd;
/** Zmienna stwierdzajaca wcisniecie przycisku odswiezania */
private boolean enableExecuteRefresh = true;
/** Metoda wywolywana przy starcie aktywnosci */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.i(TAG, "onCreate");
setContentView(R.layout.main_plan_changes);
res = getApplicationContext().getResources();
if (HttpConnect.isOnline(getApplicationContext()) == true) {
// firstRun = false;
new AsyncTaskGetPlanChanges().execute(getApplicationContext());
}
}
/**
* Metoda wyswietlajaca powiadomienie Toast
*
* @param text
* tekst powiadomienia
* @param duration
* czas wyswietlania komunikatu
* @param con
* kontekst aplikacji
*/
public void showToast(String text, int duration, Context con) {
Log.i(TAG, "showToast");
Toast.makeText(con, text, duration).show();
}
/** Metoda odswiezajaca ListView ze zmianami w planie */
private void refreshListView() {
Log.i(TAG, "refreshListView");
lvPlanChanges = (ListView) findViewById(R.id.listPlanChanges);
adapter = new ListViewAdapterPlanChanges(getApplicationContext(),
android.R.layout.simple_list_item_1, android.R.id.text1, news);
lvPlanChanges.setAdapter(adapter);
adapter.notifyDataSetChanged();
lvPlanChanges.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
TextView body = (TextView) view.findViewById(R.id.body);
if (body.getVisibility() == View.GONE) {
body.setVisibility(View.VISIBLE);
} else
body.setVisibility(View.GONE);
}
});
if (news.size() == 0) {
Toast.makeText(this, getString(R.string.no_messages),
Toast.LENGTH_LONG).show();
}
}
/**
* Metoda tworzaca menu opcji
*
* @param menu
*
* @return true, jezeli utworzono pomyslnie
*/
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.plan_changes_menu, menu);
return true;
}
/**
* Metoda sprawdza wybor elementu z menu
*
* @param item
* wybrany element menu
*
* @return true, jezeli wybrano element
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
Log.i(TAG, "onOptionsItemSelected");
switch (item.getItemId()) {
case R.id.refresh:
if (enableExecuteRefresh) {
if (HttpConnect.isOnline(getApplicationContext()) == true) {
new AsyncTaskGetPlanChanges()
.execute(getApplicationContext());
}
}
return true;
case R.id.exit:
this.finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
/** Klasa pobierajaca zmiany w planie */
private class AsyncTaskGetPlanChanges extends
AsyncTask<Context, Boolean, Void> {
/**
* ArrayList obiektow MessagePlanChanges, gdzie beda przechowywane dane
* o zmianach w planie
*/
ArrayList<MessagePlanChanges> tempArray = null;
/** Obiekt klasy Context */
Context ctx;
/** Wykonywanie zadan w tle watku glownego */
@Override
protected Void doInBackground(Context... params) {
Log.i(TAG, "doInBackground");
ctx = params[0];
if (HttpConnect.isOnline(getApplicationContext()) == true) {
tempArray = pars.getServerMessages();
if (tempArray != null) {
news = tempArray;
} else {
publishProgress(false);
}
}
return null;
}
/**
* Metoda umozliwia aktualizowanie watku glownego podczas dzialania
* PlanChangesActivity
*/
@Override
protected void onProgressUpdate(Boolean... values) {
super.onProgressUpdate(values);
Log.i(TAG, "onProgressUpdate");
if (values[0] == false)
showToast(res.getString(R.string.plan_changes_Messages), 3000,
ctx);
}
/** Metoda wykonywana przed doInBackground() */
@Override
protected void onPreExecute() {
Log.i(TAG, "onPreExecute");
pd = ProgressDialog.show(PlanChangesActivity.this,
res.getString(R.string.plan_changes_refreshing_title),
res.getString(R.string.refreshing_body), true, true);
pd.setCancelable(false);
enableExecuteRefresh = false;
}
/** Metoda wykonywana po doInBackground() */
@Override
protected void onPostExecute(Void result) {
Log.i(TAG, "onPostExecute");
pd.dismiss();
if (tempArray != null) {
refreshListView();
publishProgress(true);
}
enableExecuteRefresh = true;
}
}
@Override
protected void onStop() {
super.onStop();
finish();
}
}
| /**
* ArrayList obiektow MessagePlanChanges, gdzie beda przechowywane dane
* o zmianach w planie
*/ | package mad.widget.activities;
import java.util.ArrayList;
import mad.widget.R;
import mad.widget.connections.GetPlanChanges;
import mad.widget.connections.HttpConnect;
import mad.widget.models.ListViewAdapterPlanChanges;
import mad.widget.models.MessagePlanChanges;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.res.Resources;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;
/**
* Aktywnosc wyswietlajaca zmiany w planie w formie ListView
*
* @author Sebastian Swierczek
* @version 1.3.1
*/
public class PlanChangesActivity extends Activity {
/** Obiekt typu GetPlanChanges */
private final GetPlanChanges pars = new GetPlanChanges();
/**
* Zmienna do debuggowania.
*/
private static final String TAG = "PlanChangesActivity";
/**
* Obiekt klasy Resources, odwolujacy sie do wartosci z pliku
* res/strings.xml
*/
private Resources res;
/**
* Obiekt ArrayList zawierajacy obiekty klasy MessagePlanChanges, gdzie
* wyswietlane beda zmiany w planie
*/
private ArrayList<MessagePlanChanges> news = new ArrayList<MessagePlanChanges>();
/** Obiekt ListViewAdapterPlanChanges */
private ListViewAdapterPlanChanges adapter;
/** Obiekt ListView */
private ListView lvPlanChanges;
/** Obiekt ProgressDialog */
private ProgressDialog pd;
/** Zmienna stwierdzajaca wcisniecie przycisku odswiezania */
private boolean enableExecuteRefresh = true;
/** Metoda wywolywana przy starcie aktywnosci */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.i(TAG, "onCreate");
setContentView(R.layout.main_plan_changes);
res = getApplicationContext().getResources();
if (HttpConnect.isOnline(getApplicationContext()) == true) {
// firstRun = false;
new AsyncTaskGetPlanChanges().execute(getApplicationContext());
}
}
/**
* Metoda wyswietlajaca powiadomienie Toast
*
* @param text
* tekst powiadomienia
* @param duration
* czas wyswietlania komunikatu
* @param con
* kontekst aplikacji
*/
public void showToast(String text, int duration, Context con) {
Log.i(TAG, "showToast");
Toast.makeText(con, text, duration).show();
}
/** Metoda odswiezajaca ListView ze zmianami w planie */
private void refreshListView() {
Log.i(TAG, "refreshListView");
lvPlanChanges = (ListView) findViewById(R.id.listPlanChanges);
adapter = new ListViewAdapterPlanChanges(getApplicationContext(),
android.R.layout.simple_list_item_1, android.R.id.text1, news);
lvPlanChanges.setAdapter(adapter);
adapter.notifyDataSetChanged();
lvPlanChanges.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
TextView body = (TextView) view.findViewById(R.id.body);
if (body.getVisibility() == View.GONE) {
body.setVisibility(View.VISIBLE);
} else
body.setVisibility(View.GONE);
}
});
if (news.size() == 0) {
Toast.makeText(this, getString(R.string.no_messages),
Toast.LENGTH_LONG).show();
}
}
/**
* Metoda tworzaca menu opcji
*
* @param menu
*
* @return true, jezeli utworzono pomyslnie
*/
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.plan_changes_menu, menu);
return true;
}
/**
* Metoda sprawdza wybor elementu z menu
*
* @param item
* wybrany element menu
*
* @return true, jezeli wybrano element
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
Log.i(TAG, "onOptionsItemSelected");
switch (item.getItemId()) {
case R.id.refresh:
if (enableExecuteRefresh) {
if (HttpConnect.isOnline(getApplicationContext()) == true) {
new AsyncTaskGetPlanChanges()
.execute(getApplicationContext());
}
}
return true;
case R.id.exit:
this.finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
/** Klasa pobierajaca zmiany w planie */
private class AsyncTaskGetPlanChanges extends
AsyncTask<Context, Boolean, Void> {
/**
* ArrayList obiektow MessagePlanChanges, <SUF>*/
ArrayList<MessagePlanChanges> tempArray = null;
/** Obiekt klasy Context */
Context ctx;
/** Wykonywanie zadan w tle watku glownego */
@Override
protected Void doInBackground(Context... params) {
Log.i(TAG, "doInBackground");
ctx = params[0];
if (HttpConnect.isOnline(getApplicationContext()) == true) {
tempArray = pars.getServerMessages();
if (tempArray != null) {
news = tempArray;
} else {
publishProgress(false);
}
}
return null;
}
/**
* Metoda umozliwia aktualizowanie watku glownego podczas dzialania
* PlanChangesActivity
*/
@Override
protected void onProgressUpdate(Boolean... values) {
super.onProgressUpdate(values);
Log.i(TAG, "onProgressUpdate");
if (values[0] == false)
showToast(res.getString(R.string.plan_changes_Messages), 3000,
ctx);
}
/** Metoda wykonywana przed doInBackground() */
@Override
protected void onPreExecute() {
Log.i(TAG, "onPreExecute");
pd = ProgressDialog.show(PlanChangesActivity.this,
res.getString(R.string.plan_changes_refreshing_title),
res.getString(R.string.refreshing_body), true, true);
pd.setCancelable(false);
enableExecuteRefresh = false;
}
/** Metoda wykonywana po doInBackground() */
@Override
protected void onPostExecute(Void result) {
Log.i(TAG, "onPostExecute");
pd.dismiss();
if (tempArray != null) {
refreshListView();
publishProgress(true);
}
enableExecuteRefresh = true;
}
}
@Override
protected void onStop() {
super.onStop();
finish();
}
}
| t |
6558_2 | MaOlszewska/ObjectOrientedProgramming-2021 | 554 | src/main/java/agh/ics/oop/GrassField.java | package agh.ics.oop;
import java.util.LinkedHashMap;
import java.util.Random;
public class GrassField extends AbstractWorldMap{
private final int fieldNumber;
private final LinkedHashMap<Vector2d, Grass> grass;
public GrassField(int fieldNumber){
this.fieldNumber = fieldNumber;
this.grass = new LinkedHashMap<>();
placeGrass();
}
private void placeGrass(){
Random random = new Random();
int x ;
int y ;
for(int i = 0; i < fieldNumber; i++){
do{ // najpierw instrukcja do wykonania
x = random.nextInt((int)Math.sqrt(this.fieldNumber * 10));
y = random.nextInt((int)Math.sqrt(this.fieldNumber * 10));
}
// instanceof -sprawdzam czy zwracany obiekt z danego pola jest trawą
while(isOccupied(new Vector2d(x,y)) && (objectAt(new Vector2d(x,y)) instanceof Grass) ); // pozniej sprawdzany warunek, czyli wykona sie przynamnije raz
Grass tuft = new Grass(new Vector2d(x,y));
grass.put(tuft.getPosition(), tuft); // dodaje kępke do trawnika
mapElements.add(tuft);
boundary.addElements( tuft);
}
}
@Override
public boolean canMoveTo(Vector2d position) {
// aby można było się tam ruszyć musi być puste pole lub być kępka trawy
return !isOccupied(position) || objectAt(position) instanceof Grass ;
}
@Override
public Object objectAt(Vector2d position) {
Object object = super.objectAt(position);
if (object == null){
return grass.get(position);
}
else return object;
}
public Vector2d getLeftCorner(){return boundary.getLeftCorner();}
public Vector2d getRightCorner(){return boundary.getRightCorner();}
}
| // pozniej sprawdzany warunek, czyli wykona sie przynamnije raz | package agh.ics.oop;
import java.util.LinkedHashMap;
import java.util.Random;
public class GrassField extends AbstractWorldMap{
private final int fieldNumber;
private final LinkedHashMap<Vector2d, Grass> grass;
public GrassField(int fieldNumber){
this.fieldNumber = fieldNumber;
this.grass = new LinkedHashMap<>();
placeGrass();
}
private void placeGrass(){
Random random = new Random();
int x ;
int y ;
for(int i = 0; i < fieldNumber; i++){
do{ // najpierw instrukcja do wykonania
x = random.nextInt((int)Math.sqrt(this.fieldNumber * 10));
y = random.nextInt((int)Math.sqrt(this.fieldNumber * 10));
}
// instanceof -sprawdzam czy zwracany obiekt z danego pola jest trawą
while(isOccupied(new Vector2d(x,y)) && (objectAt(new Vector2d(x,y)) instanceof Grass) ); // pozniej sprawdzany <SUF>
Grass tuft = new Grass(new Vector2d(x,y));
grass.put(tuft.getPosition(), tuft); // dodaje kępke do trawnika
mapElements.add(tuft);
boundary.addElements( tuft);
}
}
@Override
public boolean canMoveTo(Vector2d position) {
// aby można było się tam ruszyć musi być puste pole lub być kępka trawy
return !isOccupied(position) || objectAt(position) instanceof Grass ;
}
@Override
public Object objectAt(Vector2d position) {
Object object = super.objectAt(position);
if (object == null){
return grass.get(position);
}
else return object;
}
public Vector2d getLeftCorner(){return boundary.getLeftCorner();}
public Vector2d getRightCorner(){return boundary.getRightCorner();}
}
| t |
5777_0 | MacMisDev/Ksiazka | 226 | src/main/java/me/ksiazka/model/OfferStatus.java | package me.ksiazka.model;
/*
Opis systemu statusow oferty:
Przy pierwszym wyslaniu oferty badz jej odeslaniu po zmianach
oferta ma status "pending" poniewaz czeka na akceptacje
ze strony drugiego uzytkownika. Gdy uzytkownik, ktoremu
wyslana zostala oferta zaakceptuje ja, wtedy oferta dostaje
status accepted, ale jest to wciaz akceptacja jednostronna,
dopiero kiedy drugi uzytkownik rowniez potwierdzi zgode,
oferta staje sie confirmed, tym samym jest zrealizowana i nie
zalega juz na liscie aktualnych ofert uzytkownika.
*/
public enum OfferStatus {
CONFIRMED, ACCEPTED, PENDING;
}
| /*
Opis systemu statusow oferty:
Przy pierwszym wyslaniu oferty badz jej odeslaniu po zmianach
oferta ma status "pending" poniewaz czeka na akceptacje
ze strony drugiego uzytkownika. Gdy uzytkownik, ktoremu
wyslana zostala oferta zaakceptuje ja, wtedy oferta dostaje
status accepted, ale jest to wciaz akceptacja jednostronna,
dopiero kiedy drugi uzytkownik rowniez potwierdzi zgode,
oferta staje sie confirmed, tym samym jest zrealizowana i nie
zalega juz na liscie aktualnych ofert uzytkownika.
*/ | package me.ksiazka.model;
/*
Opis systemu statusow <SUF>*/
public enum OfferStatus {
CONFIRMED, ACCEPTED, PENDING;
}
| t |
5793_1 | Maciej-Grzesik/ZPO23-L1 | 195 | LISTA 3/Zad1/src/Magazyn.java | import java.util.ArrayList;
import java.util.List;
/**
* Klasa przechowujaca obiekty produkt
*/
public class Magazyn {
private final List<Produkt> products;
public Magazyn(){
products = new ArrayList<>();
}
/**
* Metoda dodajaca produkt do listy
* @param product produkt do dodania
* @throws IllegalArgumentException kiedy produkt jest pusty
*/
public void addProduct(Produkt product){
if (product == null){
throw new IllegalArgumentException("Produkt nie moze byc pusty!");
}
products.add(product);
}
public List<Produkt> getProducts(){
return products;
}
}
| /**
* Metoda dodajaca produkt do listy
* @param product produkt do dodania
* @throws IllegalArgumentException kiedy produkt jest pusty
*/ | import java.util.ArrayList;
import java.util.List;
/**
* Klasa przechowujaca obiekty produkt
*/
public class Magazyn {
private final List<Produkt> products;
public Magazyn(){
products = new ArrayList<>();
}
/**
* Metoda dodajaca produkt <SUF>*/
public void addProduct(Produkt product){
if (product == null){
throw new IllegalArgumentException("Produkt nie moze byc pusty!");
}
products.add(product);
}
public List<Produkt> getProducts(){
return products;
}
}
| t |
3697_2 | MaciejKasperczyk/Szachy | 630 | src/Hetman.java | class Hetman extends Figura{
public Hetman(Szachownica szachownica, int wspolrzedneX,int wspolrzedneY, Kolor kolor, int gracz) {
super(szachownica,wspolrzedneX,wspolrzedneY,kolor,gracz);
}
public boolean mozliwyRuch(int wspolrzedneXRuchu, int wspolrzedneYRuchu) {
int wspolrzedneX = this.zwrocX();
int wspolrzedneY = this.zwrocY();
// Sprawdź, czy ruch jest pionowy, poziomy lub po skosie
if (wspolrzedneX == wspolrzedneXRuchu || wspolrzedneY == wspolrzedneYRuchu ||
Math.abs(wspolrzedneXRuchu - wspolrzedneX) == Math.abs(wspolrzedneYRuchu - wspolrzedneY)) {
int deltaX = Integer.compare(wspolrzedneXRuchu, wspolrzedneX);
int deltaY = Integer.compare(wspolrzedneYRuchu, wspolrzedneY);
int x = wspolrzedneX + deltaX;
int y = wspolrzedneY + deltaY;
// Sprawdź, czy na drodze hetmana nie ma żadnych innych figur
while (x != wspolrzedneXRuchu || y != wspolrzedneYRuchu) {
if (szachownica.sprawdzFigure(x, y) != null) {
return false;
}
x += deltaX;
y += deltaY;
}
// Ruch jest możliwy, jeśli pole docelowe jest puste lub zajęte przez figurę przeciwnika
Figura figuraNaDocelowychWspolrzednych = szachownica.sprawdzFigure(wspolrzedneXRuchu, wspolrzedneYRuchu);
return figuraNaDocelowychWspolrzednych == null || figuraNaDocelowychWspolrzednych.zwrocGracza() != this.gracz;
}
return false; // Ruch nie jest możliwy
}
public String toString(){
return "Hetman";
}
}
| // Ruch jest możliwy, jeśli pole docelowe jest puste lub zajęte przez figurę przeciwnika | class Hetman extends Figura{
public Hetman(Szachownica szachownica, int wspolrzedneX,int wspolrzedneY, Kolor kolor, int gracz) {
super(szachownica,wspolrzedneX,wspolrzedneY,kolor,gracz);
}
public boolean mozliwyRuch(int wspolrzedneXRuchu, int wspolrzedneYRuchu) {
int wspolrzedneX = this.zwrocX();
int wspolrzedneY = this.zwrocY();
// Sprawdź, czy ruch jest pionowy, poziomy lub po skosie
if (wspolrzedneX == wspolrzedneXRuchu || wspolrzedneY == wspolrzedneYRuchu ||
Math.abs(wspolrzedneXRuchu - wspolrzedneX) == Math.abs(wspolrzedneYRuchu - wspolrzedneY)) {
int deltaX = Integer.compare(wspolrzedneXRuchu, wspolrzedneX);
int deltaY = Integer.compare(wspolrzedneYRuchu, wspolrzedneY);
int x = wspolrzedneX + deltaX;
int y = wspolrzedneY + deltaY;
// Sprawdź, czy na drodze hetmana nie ma żadnych innych figur
while (x != wspolrzedneXRuchu || y != wspolrzedneYRuchu) {
if (szachownica.sprawdzFigure(x, y) != null) {
return false;
}
x += deltaX;
y += deltaY;
}
// Ruch jest <SUF>
Figura figuraNaDocelowychWspolrzednych = szachownica.sprawdzFigure(wspolrzedneXRuchu, wspolrzedneYRuchu);
return figuraNaDocelowychWspolrzednych == null || figuraNaDocelowychWspolrzednych.zwrocGracza() != this.gracz;
}
return false; // Ruch nie jest możliwy
}
public String toString(){
return "Hetman";
}
}
| t |
5655_4 | Mackowic/projektPZ | 2,155 | projekt/src/projekt/main_uzyController.java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package projekt;
import java.io.IOException;
import java.net.URL;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.fxml.Initializable;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.stage.Stage;
/**
* FXML Controller class
*
* @author Maciek
*/
public class main_uzyController implements Initializable {
@FXML
private Button b_zadania;
@FXML
private Button b_projekty;
@FXML
private Button b_moje_dane;
@FXML
private Button b_wyloguj;
@FXML
private Label l_name;
@FXML
private Button b_testuj;
/**
* Initializes the controller class.
*/
@Override
public void initialize(URL url, ResourceBundle rb) {
/**
* Anonimowa metoda dla przycisku b_zadania - otwiera widok
* Moje_zadania.fxml gdzie mozna zobaczyc swoje zadania
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
*/
b_zadania.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Parent moje_zadanie_parent = FXMLLoader.load(getClass().getResource("Moje_zadania.fxml"));
Scene moje_zadanie_scene = new Scene(moje_zadanie_parent);
Stage moje_zadanie_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
moje_zadanie_stage.setScene(moje_zadanie_scene);
moje_zadanie_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
/**
* Anonimowa metoda dla przycisku b_moje_dane - otwiera widok
* moje_dane.fxml gdzie mozna dane swojego konta
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
*/
b_moje_dane.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Parent moje_dane_parent = FXMLLoader.load(getClass().getResource("moje_dane.fxml"));
Scene moje_dane_scene = new Scene(moje_dane_parent);
Stage moje_dane_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
moje_dane_stage.setScene(moje_dane_scene);
moje_dane_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
/**
* Anonimowa metoda dla przycisku b_projekty - otwiera widok
* Projekty.fxml gdzie mozna zobaczyc i utworzyc swoje projekty
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
*/
b_projekty.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Parent projekty_parent = FXMLLoader.load(getClass().getResource("Projekty.fxml"));
Scene projekty_scene = new Scene(projekty_parent);
Stage projekty_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
projekty_stage.setScene(projekty_scene);
projekty_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
/**
* Anonimowa metoda dla przycisku b_wyloguj - otwiera widok login.fxml
* gdzie mozna sie zalogowac do konta
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
* @exception SQLException ex - wyjatek zajmujący się obsługą bazy
* danych
* @exception ClassNotFoundException ex - wyjatek wystepujacy kiedy nie
* mozna odnalezc klasy
*/
b_wyloguj.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/pz", "root", "");
con.close();
Parent login_parent = FXMLLoader.load(getClass().getResource("login.fxml"));
Scene login_scene = new Scene(login_parent);
Stage login_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
login_stage.setScene(login_scene);
login_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
} catch (ClassNotFoundException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
} catch (SQLException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
/**
* Anonimowa metoda dla przycisku b_testuj - otwiera widok
* testuj.fxml gdzie mozna przetestowac
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
*/
b_testuj.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Parent moje_zadanie_parent = FXMLLoader.load(getClass().getResource("testuj.fxml"));
Scene moje_zadanie_scene = new Scene(moje_zadanie_parent);
Stage moje_zadanie_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
moje_zadanie_stage.setScene(moje_zadanie_scene);
moje_zadanie_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
}
}
| /**
* Anonimowa metoda dla przycisku b_moje_dane - otwiera widok
* moje_dane.fxml gdzie mozna dane swojego konta
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
*/ | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package projekt;
import java.io.IOException;
import java.net.URL;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.fxml.Initializable;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.stage.Stage;
/**
* FXML Controller class
*
* @author Maciek
*/
public class main_uzyController implements Initializable {
@FXML
private Button b_zadania;
@FXML
private Button b_projekty;
@FXML
private Button b_moje_dane;
@FXML
private Button b_wyloguj;
@FXML
private Label l_name;
@FXML
private Button b_testuj;
/**
* Initializes the controller class.
*/
@Override
public void initialize(URL url, ResourceBundle rb) {
/**
* Anonimowa metoda dla przycisku b_zadania - otwiera widok
* Moje_zadania.fxml gdzie mozna zobaczyc swoje zadania
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
*/
b_zadania.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Parent moje_zadanie_parent = FXMLLoader.load(getClass().getResource("Moje_zadania.fxml"));
Scene moje_zadanie_scene = new Scene(moje_zadanie_parent);
Stage moje_zadanie_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
moje_zadanie_stage.setScene(moje_zadanie_scene);
moje_zadanie_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
/**
* Anonimowa metoda dla <SUF>*/
b_moje_dane.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Parent moje_dane_parent = FXMLLoader.load(getClass().getResource("moje_dane.fxml"));
Scene moje_dane_scene = new Scene(moje_dane_parent);
Stage moje_dane_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
moje_dane_stage.setScene(moje_dane_scene);
moje_dane_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
/**
* Anonimowa metoda dla przycisku b_projekty - otwiera widok
* Projekty.fxml gdzie mozna zobaczyc i utworzyc swoje projekty
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
*/
b_projekty.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Parent projekty_parent = FXMLLoader.load(getClass().getResource("Projekty.fxml"));
Scene projekty_scene = new Scene(projekty_parent);
Stage projekty_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
projekty_stage.setScene(projekty_scene);
projekty_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
/**
* Anonimowa metoda dla przycisku b_wyloguj - otwiera widok login.fxml
* gdzie mozna sie zalogowac do konta
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
* @exception SQLException ex - wyjatek zajmujący się obsługą bazy
* danych
* @exception ClassNotFoundException ex - wyjatek wystepujacy kiedy nie
* mozna odnalezc klasy
*/
b_wyloguj.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/pz", "root", "");
con.close();
Parent login_parent = FXMLLoader.load(getClass().getResource("login.fxml"));
Scene login_scene = new Scene(login_parent);
Stage login_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
login_stage.setScene(login_scene);
login_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
} catch (ClassNotFoundException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
} catch (SQLException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
/**
* Anonimowa metoda dla przycisku b_testuj - otwiera widok
* testuj.fxml gdzie mozna przetestowac
*
* @exception IOExeption ex - wyjatek odnoscie otwierania i znajdywania
* plików fmxl
*/
b_testuj.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
try {
Parent moje_zadanie_parent = FXMLLoader.load(getClass().getResource("testuj.fxml"));
Scene moje_zadanie_scene = new Scene(moje_zadanie_parent);
Stage moje_zadanie_stage = (Stage) ((Node) actionEvent.getSource()).getScene().getWindow();
moje_zadanie_stage.setScene(moje_zadanie_scene);
moje_zadanie_stage.show();
} catch (IOException ex) {
Logger.getLogger(mainController.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
}
}
| t |
8290_3 | MagdaBial/TestPoz05PodstawyNowy | 1,880 | src/Main.java | import javafx.util.Pair;
import java.security.KeyPair;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Main {
public static String zwrocImie (Integer case1) {
// Integer case1 = 5;
String imie = "";
switch (case1) {
case 1: imie = "Kasia"; break;
case 5: imie = "Tomek"; break;
case 8: imie = "Dawid"; break;
}
return imie;
}
public static Double cenaBrutto(Double cena) {
return cena*1.23;
}
public static void przedstawSie (String imie) {
System.out.println("Moje imie to "+ imie);
}
//Wpisujemy main
//Funkcja egzekucyjna
public static void main(String[] args) {
String imie = zwrocImie(5);
przedstawSie(imie);
imie = zwrocImie(1);
przedstawSie(imie);
przedstawSie(zwrocImie(10));
System.out.println("Hej, mój pierwszy program");
//zmienne
// definicja typu (String), nazwa zmiennej (napis1) + opcjonalnie przydzielenie wartosci
String napis1 = "Katarzyna Nowakowska";
// Boolean - typ logiczny, zwraca true lub false
Boolean isTomek = napis1.contains("Tomek");
System.out.println(isTomek);
//Integer - typ numeryczny liczb calkowitych, Integer to klasa wrapujaca typ prsty ins (daje metody ulatwiajace prece z danym typem)
Integer liczba1 = 2;
// Long - liczba całkowita, ale duzo dluzsza
Long liczba2 = Long.valueOf(1302);
liczba1.equals(liczba2);
//Float - typ numeryczny zmiennoprzecinkowy
double ulamek1 = 10.55;
//Double - zmiennoprzecinkowa, inny zakres, większy zakres
Double ulamek2 = 10.5;
// kolekcje
//Lista = zbior elementow w indeksie
List<String> lista1 = new ArrayList<>();
lista1.add(napis1);
lista1.add("Tomek");
System.out.println(lista1.toString());
//HashMap - slownik trzymający pary klucz-wartość
HashMap<String, Integer> mapa1 = new HashMap<>();
mapa1.put(napis1, liczba1);
mapa1.put("Tomek", 5);
System.out.println(mapa1.toString());
//Pair - slownik tylko jedna para klucz wartosc
Pair<String, Integer> mojaPara = new Pair<>("Kasia", 1);
String napis2 = mojaPara.getKey();
napis2 += mojaPara.getValue().toString();
System.out.println(napis2);
//Pętle
//Pętla for
//Warunek początkowy; warunek końcowy; modyfikator licznika
//warunek końcowy (wartość końcowa licznika;
//modyfikator licznika i++ oznacza, że i będzie większe o 1 po przejściu pętli
for (Integer i = 0; i < 5; i++) {
System.out.println("Wartosc licznika:" + i.toString());
}
Integer i = 0;
while (i < 5) {
System.out.println("Jestem w while po raz" + i.toString());
i++;
}
//Break to specjalne slowo, które pozwala zakończyć działanie petli
//Continue pozwala przejść do kolejnej interakcji z pominięciem kodu pod tym słówkiem
while (true) {
i++;
if (i.equals(7))
continue;
System.out.print(" " +i.toString());
if (i.equals(10))
break;
}
//Petla do while - zawsze wykona się chociaż jedna interakcja
do {
System.out.println("Jestem w do while" + i.toString());
i++;
}while(i<10);
//Petla for each na liscie
for (String el: lista1) {
System.out.println("Element listy: " + el);
}
//Petla for each na mapie #TODO
//for(String el: mapa1)()
//Instrukcje warunkowe
//Instrukcje if..else if... else
if (lista1.size() ==2){
System.out.println("Hej, jestem w instrukcji warunkowej");
}
if (lista1.size()<1){
System.out.println("Z tym warunkiem nigdy się nie wypisze");
}else{
System.out.println("Jestem w instrukcji else");
}
if (lista1.size()<1) {
System.out.println("Nie wykonam sie");
}else if(lista1.size() ==2){
System.out.println("Ja się wykonam");
}else{
System.out.println("Ja się już nie wykonam, bo warunek jest spelniony");
}
//Instrukcja warunkowa switch case, na koncu każdego swich case powinno się znaleźć słówko break
i=2;
String message = "Moje imie to";
switch (i) {
case 2: message += "Kasia"; break;
case 5: message += "Tomek"; break;
case 8: message += "Dawid"; break;
}
System.out.println(message);
HashMap<String, Double> owoce = new HashMap<>();
owoce.put("jablko", 2.5);
owoce.put("banan", 4.8);
owoce.put("gruszka", 6.29);
List <String> nazwyOwocow = new ArrayList<>();
nazwyOwocow.add("jablko");
nazwyOwocow.add("banan");
nazwyOwocow.add("gruszka");
Double cenaSumaryczna = 0.0;
for( i =0; i<owoce.size(); i++) {
String owoc = nazwyOwocow.get(i);
cenaSumaryczna += cenaBrutto(owoce.get(owoc));
System.out.println(owoc);
System.out.println(cenaBrutto(owoce.get(owoc)));
}
System.out.println("Cena Twoich zakupów to: " +cenaSumaryczna.toString());
}
}
| //Integer - typ numeryczny liczb calkowitych, Integer to klasa wrapujaca typ prsty ins (daje metody ulatwiajace prece z danym typem) | import javafx.util.Pair;
import java.security.KeyPair;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Main {
public static String zwrocImie (Integer case1) {
// Integer case1 = 5;
String imie = "";
switch (case1) {
case 1: imie = "Kasia"; break;
case 5: imie = "Tomek"; break;
case 8: imie = "Dawid"; break;
}
return imie;
}
public static Double cenaBrutto(Double cena) {
return cena*1.23;
}
public static void przedstawSie (String imie) {
System.out.println("Moje imie to "+ imie);
}
//Wpisujemy main
//Funkcja egzekucyjna
public static void main(String[] args) {
String imie = zwrocImie(5);
przedstawSie(imie);
imie = zwrocImie(1);
przedstawSie(imie);
przedstawSie(zwrocImie(10));
System.out.println("Hej, mój pierwszy program");
//zmienne
// definicja typu (String), nazwa zmiennej (napis1) + opcjonalnie przydzielenie wartosci
String napis1 = "Katarzyna Nowakowska";
// Boolean - typ logiczny, zwraca true lub false
Boolean isTomek = napis1.contains("Tomek");
System.out.println(isTomek);
//Integer - <SUF>
Integer liczba1 = 2;
// Long - liczba całkowita, ale duzo dluzsza
Long liczba2 = Long.valueOf(1302);
liczba1.equals(liczba2);
//Float - typ numeryczny zmiennoprzecinkowy
double ulamek1 = 10.55;
//Double - zmiennoprzecinkowa, inny zakres, większy zakres
Double ulamek2 = 10.5;
// kolekcje
//Lista = zbior elementow w indeksie
List<String> lista1 = new ArrayList<>();
lista1.add(napis1);
lista1.add("Tomek");
System.out.println(lista1.toString());
//HashMap - slownik trzymający pary klucz-wartość
HashMap<String, Integer> mapa1 = new HashMap<>();
mapa1.put(napis1, liczba1);
mapa1.put("Tomek", 5);
System.out.println(mapa1.toString());
//Pair - slownik tylko jedna para klucz wartosc
Pair<String, Integer> mojaPara = new Pair<>("Kasia", 1);
String napis2 = mojaPara.getKey();
napis2 += mojaPara.getValue().toString();
System.out.println(napis2);
//Pętle
//Pętla for
//Warunek początkowy; warunek końcowy; modyfikator licznika
//warunek końcowy (wartość końcowa licznika;
//modyfikator licznika i++ oznacza, że i będzie większe o 1 po przejściu pętli
for (Integer i = 0; i < 5; i++) {
System.out.println("Wartosc licznika:" + i.toString());
}
Integer i = 0;
while (i < 5) {
System.out.println("Jestem w while po raz" + i.toString());
i++;
}
//Break to specjalne slowo, które pozwala zakończyć działanie petli
//Continue pozwala przejść do kolejnej interakcji z pominięciem kodu pod tym słówkiem
while (true) {
i++;
if (i.equals(7))
continue;
System.out.print(" " +i.toString());
if (i.equals(10))
break;
}
//Petla do while - zawsze wykona się chociaż jedna interakcja
do {
System.out.println("Jestem w do while" + i.toString());
i++;
}while(i<10);
//Petla for each na liscie
for (String el: lista1) {
System.out.println("Element listy: " + el);
}
//Petla for each na mapie #TODO
//for(String el: mapa1)()
//Instrukcje warunkowe
//Instrukcje if..else if... else
if (lista1.size() ==2){
System.out.println("Hej, jestem w instrukcji warunkowej");
}
if (lista1.size()<1){
System.out.println("Z tym warunkiem nigdy się nie wypisze");
}else{
System.out.println("Jestem w instrukcji else");
}
if (lista1.size()<1) {
System.out.println("Nie wykonam sie");
}else if(lista1.size() ==2){
System.out.println("Ja się wykonam");
}else{
System.out.println("Ja się już nie wykonam, bo warunek jest spelniony");
}
//Instrukcja warunkowa switch case, na koncu każdego swich case powinno się znaleźć słówko break
i=2;
String message = "Moje imie to";
switch (i) {
case 2: message += "Kasia"; break;
case 5: message += "Tomek"; break;
case 8: message += "Dawid"; break;
}
System.out.println(message);
HashMap<String, Double> owoce = new HashMap<>();
owoce.put("jablko", 2.5);
owoce.put("banan", 4.8);
owoce.put("gruszka", 6.29);
List <String> nazwyOwocow = new ArrayList<>();
nazwyOwocow.add("jablko");
nazwyOwocow.add("banan");
nazwyOwocow.add("gruszka");
Double cenaSumaryczna = 0.0;
for( i =0; i<owoce.size(); i++) {
String owoc = nazwyOwocow.get(i);
cenaSumaryczna += cenaBrutto(owoce.get(owoc));
System.out.println(owoc);
System.out.println(cenaBrutto(owoce.get(owoc)));
}
System.out.println("Cena Twoich zakupów to: " +cenaSumaryczna.toString());
}
}
| t |
9034_3 | MagdaTom/Magdalena_Tomaszewska-kodilla_tester | 356 | javastart/src/main/java/arrays_iterate/numbers/Numbers.java | package arrays_iterate.numbers;
//Wczytaj od użytkownika dowolną liczbę całkowitą różną od 0.
// Jeżeli liczba jest większa od 0 wyświetl na ekranie wszystkie liczby z przedziału [0, N],
// gdzie N jest liczbą podaną przez użytkownika z odstępem co 0.1.
// Jeśli liczba jest mniejsza od 0 wyświetl liczby od 0 do N (w porządku malejącym).
import java.util.Scanner;
public class Numbers {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Provide number");
double number = scanner.nextInt();
if(number > 0 ) {
for (double i = 0; i < (number + 0.1); i += 0.1)
System.out.printf("%.1f ", i);
}else if(number < 0){
for(double i = 0; i > (number - 0.1); i-=0.1)
System.out.println(i);
}
// Zapis %.1f oznacza liczbę zmiennoprzecinkową zaokrągloną do 1 miejsca po przecinku.
}
}
| // Jeśli liczba jest mniejsza od 0 wyświetl liczby od 0 do N (w porządku malejącym). | package arrays_iterate.numbers;
//Wczytaj od użytkownika dowolną liczbę całkowitą różną od 0.
// Jeżeli liczba jest większa od 0 wyświetl na ekranie wszystkie liczby z przedziału [0, N],
// gdzie N jest liczbą podaną przez użytkownika z odstępem co 0.1.
// Jeśli liczba <SUF>
import java.util.Scanner;
public class Numbers {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Provide number");
double number = scanner.nextInt();
if(number > 0 ) {
for (double i = 0; i < (number + 0.1); i += 0.1)
System.out.printf("%.1f ", i);
}else if(number < 0){
for(double i = 0; i > (number - 0.1); i-=0.1)
System.out.println(i);
}
// Zapis %.1f oznacza liczbę zmiennoprzecinkową zaokrągloną do 1 miejsca po przecinku.
}
}
| t |
10002_7 | MaksymilianWojcik/JavaSQLDataBase | 702 | src/BazyDanych/MySQLConnector.java | package BazyDanych;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
public class MySQLConnector {
//SINGLETON - obejrzec 05:20 - 05:32 zeby ogarnac o co chodzi bo sie wylaczylem
private static MySQLConnector instance;
private final static String DBURL = "jdbc:mysql://5.135.218.27/maks";
private final static String DBLOGIN = "root";
private final static String DBPASSWORD = "10135886";
private Connection conn;
//tutaj tak z dupy tlumaczac jescze raz po co ten singleton
//jak tworzymy nowe obiekty bazy danych to musimy sie laczyc za kazdym razem
//z baza danych. A jak stworzymy singleton to mamy juz jedno stale polaczenie
//i szybciej to dziala
private MySQLConnector(){
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(DBURL, DBLOGIN, DBPASSWORD);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Polaczono z baza danych");
}
//NIE UZYWAC W WATKACH !!!!! Do watkow co prawda dopiero dojedziemy
//no jeszce ni ebbylo, ale to taka przestroga
public static MySQLConnector getINSTANCE(){
if(instance == null){
instance = new MySQLConnector();
}
return instance;
}
public Statement getStatement(){
try {
return conn.createStatement();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public PreparedStatement getPreparedStatement(String sql){
try {
return conn.prepareStatement(sql);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}
| //NIE UZYWAC W WATKACH !!!!! Do watkow co prawda dopiero dojedziemy
| package BazyDanych;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
public class MySQLConnector {
//SINGLETON - obejrzec 05:20 - 05:32 zeby ogarnac o co chodzi bo sie wylaczylem
private static MySQLConnector instance;
private final static String DBURL = "jdbc:mysql://5.135.218.27/maks";
private final static String DBLOGIN = "root";
private final static String DBPASSWORD = "10135886";
private Connection conn;
//tutaj tak z dupy tlumaczac jescze raz po co ten singleton
//jak tworzymy nowe obiekty bazy danych to musimy sie laczyc za kazdym razem
//z baza danych. A jak stworzymy singleton to mamy juz jedno stale polaczenie
//i szybciej to dziala
private MySQLConnector(){
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(DBURL, DBLOGIN, DBPASSWORD);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Polaczono z baza danych");
}
//NIE UZYWAC <SUF>
//no jeszce ni ebbylo, ale to taka przestroga
public static MySQLConnector getINSTANCE(){
if(instance == null){
instance = new MySQLConnector();
}
return instance;
}
public Statement getStatement(){
try {
return conn.createStatement();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public PreparedStatement getPreparedStatement(String sql){
try {
return conn.prepareStatement(sql);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}
| t |
8362_4 | MaksymilianWojcik/MasteringNetworkingOne | 1,434 | app/src/main/java/com/example/mwojcik/retrofitone/retrofit/NetworkUtilRetrofit.java | package com.example.mwojcik.retrofitone.retrofit;
import android.util.Log;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
/***
*
* Retrofit to REST Client. Ulatwia otrzymywania i uploadaowanie JSONow czy innych struktur danych przez
* oparete na REST webserwisy. W Retroficie możemy skonfigurować jaki konwerter chcemy użyć do serializacji
* danych. Dla np. JSONA możemy użyć GSONa, czy Jacksona, ale możemy dodać customowe konwertery. Retrofit do
* HTTP Requestów wykorzystuje OkHttp.
*
* Przydatne linki
* - http://www.jsonschema2pojo.org/
*
* W Retorficie potrzebujemy tak naprawdę na start 3 klas: model (który mapowany będzie na JSONA),
* interfejsy które definiują możliwe operacje HTTP, oraz klasę dostarczająca nstancje Retrofit.Buildera (instancja
* ta wykorzystuje interfejs i Builder API, który pozwala definiować endpointsy URLi do operacji HTTP)
*
* Każda metoda interfejsu reprezentuje jeden możliwy API call. Musi mieć więc jakąś adnotacje HTTP, jak np. GET, POST
* itp. do określenia typu requestu, a także musi mieć relatywny adres URL (endpoint). Wartość zwracana z takiej
* metody wrapuje responsa w obiekt Call, który jest typu oczekiwanego wyniku.:
* @GET("users")
* Call<List<User>> getUsers();
* Możemy użyć bloków zastępujących i querować parametry by dostosować URL. Zastępujący blok dodany jest do relatywnego
* URLa z {}. Z pomocą adnotacji @Path przed parametrem metody, wartość tego parametru jest powioązana z konkretnym
* blokiem zastępczym:
* @GET("users/{name}/commits")
* Call<List<Commit>> getCommitsByName(@Path("name") String name)
*
* Parametry query dodane są z adnotacją @Query do parametru metody. Są automatycznie dodane na końcu URL
* @GET("users")
* Call<User> getUserById(@Query("id") Integer id)
*
* Adnotacja @Body na parametrze metody mówi Retrofitowy żeby użył obiektu jako request body calla:
* @POST("users")
* Call<User> postUser(@Body User user)
*
* 1. Najpeirw trzeba dodać dependency w gradlu:
* implementation 'com.squareup.retrofit2:retrofit:2.4.0'
* 2. Dobrze stworzyć sobie klasę z obiektem Retorfita (kontroler retrofita) i zdefiniować REST API dla Retrofita poprzez interfejs
* 3.
*
*/
public class NetworkUtilRetrofit implements Callback<SimpleModel> {
public void start(){
Gson gson = new GsonBuilder()
.setLenient()
.create();
//dodajemy sobei interceptora
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient okHttpClient = new OkHttpClient.Builder().addInterceptor(interceptor).build();
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://reqres.in/")
.addConverterFactory(GsonConverterFactory.create(gson))
//zeby dodac interceptora
.client(okHttpClient)
.build();
RegresAPI regresAPI = retrofit.create(RegresAPI.class);
Call<SimpleModel> call = regresAPI.loadData("1");
// Call call = regresAPI.loadDataSimple("1");
//Uzywamy enqueue do asynchronicznego wywołania - po co blokowac. Do synchronicznego
//uzylibysmy call.execute(this);
call.enqueue(this);
}
@Override
public void onResponse(Call<SimpleModel> call, Response<SimpleModel> response) {
if(response.isSuccessful()){
// List<SimpleModel> simpleModelList = response.body();
Log.d("RetrofitResponse", String.valueOf(response.body()));
SimpleModel simpleModel = (SimpleModel) response.body();
Log.d("RetrofitRespons", String.valueOf(simpleModel.getPage()));
for (SimpleData data : simpleModel.getSimpleDataList()){
Log.d("SimpleDataObject", data.toString());
}
} else {
Log.d("RetrofitResponse", "Error!!!!");
}
}
@Override
public void onFailure(Call<SimpleModel> call, Throwable t) {
Log.d("RetrofitResponse", "Failure!!!!");
Log.d("RetrofitResponse", t.toString());
Log.d("RetrofitResponse", call.toString());
}
}
| //Uzywamy enqueue do asynchronicznego wywołania - po co blokowac. Do synchronicznego | package com.example.mwojcik.retrofitone.retrofit;
import android.util.Log;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
/***
*
* Retrofit to REST Client. Ulatwia otrzymywania i uploadaowanie JSONow czy innych struktur danych przez
* oparete na REST webserwisy. W Retroficie możemy skonfigurować jaki konwerter chcemy użyć do serializacji
* danych. Dla np. JSONA możemy użyć GSONa, czy Jacksona, ale możemy dodać customowe konwertery. Retrofit do
* HTTP Requestów wykorzystuje OkHttp.
*
* Przydatne linki
* - http://www.jsonschema2pojo.org/
*
* W Retorficie potrzebujemy tak naprawdę na start 3 klas: model (który mapowany będzie na JSONA),
* interfejsy które definiują możliwe operacje HTTP, oraz klasę dostarczająca nstancje Retrofit.Buildera (instancja
* ta wykorzystuje interfejs i Builder API, który pozwala definiować endpointsy URLi do operacji HTTP)
*
* Każda metoda interfejsu reprezentuje jeden możliwy API call. Musi mieć więc jakąś adnotacje HTTP, jak np. GET, POST
* itp. do określenia typu requestu, a także musi mieć relatywny adres URL (endpoint). Wartość zwracana z takiej
* metody wrapuje responsa w obiekt Call, który jest typu oczekiwanego wyniku.:
* @GET("users")
* Call<List<User>> getUsers();
* Możemy użyć bloków zastępujących i querować parametry by dostosować URL. Zastępujący blok dodany jest do relatywnego
* URLa z {}. Z pomocą adnotacji @Path przed parametrem metody, wartość tego parametru jest powioązana z konkretnym
* blokiem zastępczym:
* @GET("users/{name}/commits")
* Call<List<Commit>> getCommitsByName(@Path("name") String name)
*
* Parametry query dodane są z adnotacją @Query do parametru metody. Są automatycznie dodane na końcu URL
* @GET("users")
* Call<User> getUserById(@Query("id") Integer id)
*
* Adnotacja @Body na parametrze metody mówi Retrofitowy żeby użył obiektu jako request body calla:
* @POST("users")
* Call<User> postUser(@Body User user)
*
* 1. Najpeirw trzeba dodać dependency w gradlu:
* implementation 'com.squareup.retrofit2:retrofit:2.4.0'
* 2. Dobrze stworzyć sobie klasę z obiektem Retorfita (kontroler retrofita) i zdefiniować REST API dla Retrofita poprzez interfejs
* 3.
*
*/
public class NetworkUtilRetrofit implements Callback<SimpleModel> {
public void start(){
Gson gson = new GsonBuilder()
.setLenient()
.create();
//dodajemy sobei interceptora
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient okHttpClient = new OkHttpClient.Builder().addInterceptor(interceptor).build();
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://reqres.in/")
.addConverterFactory(GsonConverterFactory.create(gson))
//zeby dodac interceptora
.client(okHttpClient)
.build();
RegresAPI regresAPI = retrofit.create(RegresAPI.class);
Call<SimpleModel> call = regresAPI.loadData("1");
// Call call = regresAPI.loadDataSimple("1");
//Uzywamy enqueue <SUF>
//uzylibysmy call.execute(this);
call.enqueue(this);
}
@Override
public void onResponse(Call<SimpleModel> call, Response<SimpleModel> response) {
if(response.isSuccessful()){
// List<SimpleModel> simpleModelList = response.body();
Log.d("RetrofitResponse", String.valueOf(response.body()));
SimpleModel simpleModel = (SimpleModel) response.body();
Log.d("RetrofitRespons", String.valueOf(simpleModel.getPage()));
for (SimpleData data : simpleModel.getSimpleDataList()){
Log.d("SimpleDataObject", data.toString());
}
} else {
Log.d("RetrofitResponse", "Error!!!!");
}
}
@Override
public void onFailure(Call<SimpleModel> call, Throwable t) {
Log.d("RetrofitResponse", "Failure!!!!");
Log.d("RetrofitResponse", t.toString());
Log.d("RetrofitResponse", call.toString());
}
}
| t |
7639_1 | MarcinLachowicz/ADT-analysis | 357 | src/main/java/pl/edu/agh/model/AnomalyReport.java | package pl.edu.agh.model;
import org.apache.commons.lang3.tuple.Pair;
import java.util.Date;
import java.util.List;
/**
* Created by Wiktor on 2017-01-21.
*/
public class AnomalyReport {
// można zastąpić wewnętrzną reprezentacją, żeby nie przekazywać setki razy id sensora dla zapytania o konkretny sensor?
private List<SensorEntry> entries;
private List<Date> anomalies;
private List<Pair<Date, Date>> anomaliesDates;
public List<Date> getAnomalies() {
return anomalies;
}
public void setAnomalies(List<Date> anomalies) {
this.anomalies = anomalies;
}
public List<SensorEntry> getEntries() {
return entries;
}
public void setEntries(List<SensorEntry> entries) {
this.entries = entries;
}
public List<Pair<Date, Date>> getAnomaliesDates() {
return anomaliesDates;
}
public void setAnomaliesDates(List<Pair<Date, Date>> anomaliesDates) {
this.anomaliesDates = anomaliesDates;
}
}
| // można zastąpić wewnętrzną reprezentacją, żeby nie przekazywać setki razy id sensora dla zapytania o konkretny sensor? | package pl.edu.agh.model;
import org.apache.commons.lang3.tuple.Pair;
import java.util.Date;
import java.util.List;
/**
* Created by Wiktor on 2017-01-21.
*/
public class AnomalyReport {
// można zastąpić <SUF>
private List<SensorEntry> entries;
private List<Date> anomalies;
private List<Pair<Date, Date>> anomaliesDates;
public List<Date> getAnomalies() {
return anomalies;
}
public void setAnomalies(List<Date> anomalies) {
this.anomalies = anomalies;
}
public List<SensorEntry> getEntries() {
return entries;
}
public void setEntries(List<SensorEntry> entries) {
this.entries = entries;
}
public List<Pair<Date, Date>> getAnomaliesDates() {
return anomaliesDates;
}
public void setAnomaliesDates(List<Pair<Date, Date>> anomaliesDates) {
this.anomaliesDates = anomaliesDates;
}
}
| t |
10575_1 | MarcinPasynczuk/ZadaniaPodastawyProgramowaniaJava | 578 | Ćwiczenia/Dostawa/Produkt.java | class Produkt{
public int id;
public String nazwa;
public String kodKreskowy;
boolean czyKodKreskowyOK(){
boolean czyOk = true;
// kod kreskowy EAN-13 ma mieć zawsze 13 znakow
if(kodKreskowy.length() != 13)
czyOk = false;
else
{
// jesli ma 13 znakow, spr czy kazdy znak to cyfra
for(int i = 0; i<13; i++)
{
if(kodKreskowy.charAt(i) < '0' ||
kodKreskowy.charAt(i) > '9')
{
czyOk = false;
break;
}
}
}
return czyOk;
}
boolean czyPL(){
boolean czyOk = czyKodKreskowyOK();
if(czyOk){
if(kodKreskowy.startsWith("590"))
return true;
else
return false;
}
else{
System.out.println("Err#1 Kod kresk niepoprawny");
return false;
}
}
boolean czyPL(int x){
if(kodKreskowy.startsWith("590"))
return true;
else
return false;
}
void wypiszDane(){
System.out.println("Id: " + id);
System.out.println("Nazwa: " + nazwa);
System.out.println("Kod K: " + kodKreskowy);
}
Produkt(){
id = -1;
nazwa = "empty";
kodKreskowy = "0000000000000";
}
Produkt(int newId, String newNazwa, String newKodKreskowy){
id = newId;
nazwa = newNazwa;
kodKreskowy = newKodKreskowy;
}
}
| // jesli ma 13 znakow, spr czy kazdy znak to cyfra
| class Produkt{
public int id;
public String nazwa;
public String kodKreskowy;
boolean czyKodKreskowyOK(){
boolean czyOk = true;
// kod kreskowy EAN-13 ma mieć zawsze 13 znakow
if(kodKreskowy.length() != 13)
czyOk = false;
else
{
// jesli ma <SUF>
for(int i = 0; i<13; i++)
{
if(kodKreskowy.charAt(i) < '0' ||
kodKreskowy.charAt(i) > '9')
{
czyOk = false;
break;
}
}
}
return czyOk;
}
boolean czyPL(){
boolean czyOk = czyKodKreskowyOK();
if(czyOk){
if(kodKreskowy.startsWith("590"))
return true;
else
return false;
}
else{
System.out.println("Err#1 Kod kresk niepoprawny");
return false;
}
}
boolean czyPL(int x){
if(kodKreskowy.startsWith("590"))
return true;
else
return false;
}
void wypiszDane(){
System.out.println("Id: " + id);
System.out.println("Nazwa: " + nazwa);
System.out.println("Kod K: " + kodKreskowy);
}
Produkt(){
id = -1;
nazwa = "empty";
kodKreskowy = "0000000000000";
}
Produkt(int newId, String newNazwa, String newKodKreskowy){
id = newId;
nazwa = newNazwa;
kodKreskowy = newKodKreskowy;
}
}
| t |
6694_1 | Mariusz-Borczuk/Zadania-Java | 814 | JavaZad1.java | //Użytkownik podaje n łańcuchów. Należy zapamiętać łańcuch
//najdłuższy. Podać, ile ma znaków i go wypisać.
//Policzyć wystąpienia litery podanej przez użytkownika w łańcuchu
import java.util.Scanner;
public class JavaZad1 {
public static void main(String[] args) throws Exception {
Scanner scanerek = new Scanner(System.in);
// Ile lancuchow chcesz porownywac?
System.out.println("Podaj liczbe lancuchow, ktore chcesz porownywac:");
int n = scanerek.nextInt();
scanerek.nextLine(); // czyszczenie bufora
// Wczytywanie lancuchow
String[] strings = new String[n];
for (int i = 0; i < n; i++) {
System.out.println("Podaj lancuch nr " + (i + 1) + ": ");
strings[i] = scanerek.nextLine().trim();
}
// Szukanie najdluzszego lancucha
int max = strings[0].length();
int index = 0;
for (int i = 1; i < n; i++) {
if (strings[i].length() > max) {
max = strings[i].length();
index = i;
} else if (strings[i].length() == max) {
System.out.println("Lancuch nr " + (i + 1) + " ma tyle samo znakow co lancuch nr " + (index + 1));
}
}
// Wypisywanie lancuchow
for (int i = 0; i < n; i++) {
System.out.println("Lancuch nr " + (i + 1) + " wyglada: \"" + strings[i] + "\" i ma " + strings[i].length()
+ " znakow.");
}
// Wypisywanie najdluzszego lancucha
System.out.println("Najdluzszy lancuch to: " + strings[index] + " i ma on " + max + " znakow.");
// Wypisywanie wystapien znaku w lancuchu
System.out.println("Podaj lancuch, w ktorym chcesz sprawdzic wystepowanie czestotliwosc dowolnego znaku: ");
int j = scanerek.nextInt();
String s = strings[j - 1];
System.out.println("Podaj znaku, ktora chcesz policzyc w lancuchu " + j + ": ");
char c = scanerek.next().charAt(0);
// sprawdzanie wystapien
int count = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == c) {
count++;
}
}
System.out.println("Liczba wystapien litery " + c + " we wszystkich lancuchach to: " + count);
scanerek.close();
}
} | //najdłuższy. Podać, ile ma znaków i go wypisać. | //Użytkownik podaje n łańcuchów. Należy zapamiętać łańcuch
//najdłuższy. Podać, <SUF>
//Policzyć wystąpienia litery podanej przez użytkownika w łańcuchu
import java.util.Scanner;
public class JavaZad1 {
public static void main(String[] args) throws Exception {
Scanner scanerek = new Scanner(System.in);
// Ile lancuchow chcesz porownywac?
System.out.println("Podaj liczbe lancuchow, ktore chcesz porownywac:");
int n = scanerek.nextInt();
scanerek.nextLine(); // czyszczenie bufora
// Wczytywanie lancuchow
String[] strings = new String[n];
for (int i = 0; i < n; i++) {
System.out.println("Podaj lancuch nr " + (i + 1) + ": ");
strings[i] = scanerek.nextLine().trim();
}
// Szukanie najdluzszego lancucha
int max = strings[0].length();
int index = 0;
for (int i = 1; i < n; i++) {
if (strings[i].length() > max) {
max = strings[i].length();
index = i;
} else if (strings[i].length() == max) {
System.out.println("Lancuch nr " + (i + 1) + " ma tyle samo znakow co lancuch nr " + (index + 1));
}
}
// Wypisywanie lancuchow
for (int i = 0; i < n; i++) {
System.out.println("Lancuch nr " + (i + 1) + " wyglada: \"" + strings[i] + "\" i ma " + strings[i].length()
+ " znakow.");
}
// Wypisywanie najdluzszego lancucha
System.out.println("Najdluzszy lancuch to: " + strings[index] + " i ma on " + max + " znakow.");
// Wypisywanie wystapien znaku w lancuchu
System.out.println("Podaj lancuch, w ktorym chcesz sprawdzic wystepowanie czestotliwosc dowolnego znaku: ");
int j = scanerek.nextInt();
String s = strings[j - 1];
System.out.println("Podaj znaku, ktora chcesz policzyc w lancuchu " + j + ": ");
char c = scanerek.next().charAt(0);
// sprawdzanie wystapien
int count = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == c) {
count++;
}
}
System.out.println("Liczba wystapien litery " + c + " we wszystkich lancuchach to: " + count);
scanerek.close();
}
} | t |
7706_3 | MarkoKord/marko_kordic-kodilla_tester | 383 | src/main/java/RandomNumbers.java | import java.util.Random;
public class RandomNumbers {
public static void main(String[] args) {
int getCountOfRandomNumber = getCountOfRandomNumber(5000); // odwołanie do metody, żeby printować wynik
}
static int getCountOfRandomNumber(int max) {
int minNumb = 30, maxNumb = 1; //określenie najwyższej i najniższej warotsci
Random random = new Random();
int numbers = random.nextInt(5000); //deklaracja że suma petli osiaga 5k
int result = 0;
int sum = 0;
while (sum < max) {
int temp = random.nextInt(31); // zakres pętli pętla zaczyna się od int sum=0 do 30
sum += temp;
result++;
if (temp < minNumb) { // jeśli liczba losowana z przedziału temp jest mniejsza od minNumb
minNumb = temp;
}
if (temp > maxNumb) {
maxNumb = temp;
}
System.out.println("najmnniejsza wylosowana to:" + minNumb);
System.out.println("największa wylosowana to:" + maxNumb);
}
return result++;
}
}
| // zakres pętli pętla zaczyna się od int sum=0 do 30 | import java.util.Random;
public class RandomNumbers {
public static void main(String[] args) {
int getCountOfRandomNumber = getCountOfRandomNumber(5000); // odwołanie do metody, żeby printować wynik
}
static int getCountOfRandomNumber(int max) {
int minNumb = 30, maxNumb = 1; //określenie najwyższej i najniższej warotsci
Random random = new Random();
int numbers = random.nextInt(5000); //deklaracja że suma petli osiaga 5k
int result = 0;
int sum = 0;
while (sum < max) {
int temp = random.nextInt(31); // zakres pętli <SUF>
sum += temp;
result++;
if (temp < minNumb) { // jeśli liczba losowana z przedziału temp jest mniejsza od minNumb
minNumb = temp;
}
if (temp > maxNumb) {
maxNumb = temp;
}
System.out.println("najmnniejsza wylosowana to:" + minNumb);
System.out.println("największa wylosowana to:" + maxNumb);
}
return result++;
}
}
| t |
6282_4 | Mat00000/KLDD | 2,086 | Analizator/Java/Analizator.java | import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
/**
*
* @author Jakub Duda, Mateusz Laskowski, Pjoter, Mikis
*
*/
public class Analizator {
int delta = 36; //odległość miedzy środkami
int bus_lifetime = 80; // czas życia busa
ArrayList<Bus> c_buses = new ArrayList<>(); //Busy w pamięci/ pamięta tylko poprzednią klatke
ArrayList<Bus> buses = new ArrayList<>(); //Busy które przejechały (zliczone)
ArrayList<Bus> r_buses = new ArrayList<>(); // Busy do usunięcia
boolean flag = false;
public static void main(String[] args) throws IOException {
Analizator yolo = new Analizator();
yolo.input();
int i = 0;
String temp;
BufferedWriter writer = new BufferedWriter(new FileWriter("outputAnalizator.txt"));
for (Bus b : yolo.buses) {
i++;
//System.out.println("Bus "+i);
System.out.println("LT "+ b.life_time);
temp = "LT " + b.life_time + "\n";
writer.write(temp);
switch(b.direction) {
case -1: System.out.println("Direction: L -> R");
temp = "Direction: L -> R\n";
break;
case 0: System.out.println("Direction: S");
temp = "Direction: S\n";
break;
case 1: System.out.println("Direction: R -> L");
temp = "Direction: R -> L\n";
break;
default: System.out.println("Direction: undefinded");
temp = "Direction: undefinded\n";
break;
}
writer.write(temp);
}
System.out.println("Bus "+i);
temp = "Bus " + i;
writer.write(temp);
writer.close();
}
// Metoda zwraca wynik czy dany bus_new jest tym samym busem
public boolean compareBus(Bus b_new, Bus b) {
int x = (b_new.center.x - b.center.x) * (b_new.center.x - b.center.x);
int y = (b_new.center.y - b.center.y) * (b_new.center.y - b.center.y);
double d = Math.sqrt((x + y));
//System.out.println("Odległość miedzy busami" + d);
return (d < delta);
}
public boolean overlapFileter(Bus b_new, Bus b){//true gdy się nakłada
//sprawdzenie przypadku nakładania sie obiektów
if(b.life_time==b_new.life_time){
//b to ten wiekszy
if((b.top<=b_new.top) && (b.bottom>=b_new.bottom) && (b.left<=b_new.left)){
return true;
}else{
return false;
}
}
return false;
}
public void copyBus(Bus b_new, Bus b){
b.center = b_new.center;
b.life_time = b_new.life_time;
b.right = b_new.right;
b.top = b_new.top;
b.bottom = b_new.bottom;
b.left = b_new.left;
b.vector = b_new.vector;
b.direction = b_new.direction;
b.surface = b_new.surface;
b.lastFrame = b_new.lastFrame;
}
public int checkDirection(Bus b_new, Bus b) {
// System.out.println("OLD " + b.vector);
// System.out.println("NEW " + b_new.vector);
// if(b.direction != 0) return b.direction; // jeżeli miał już kierunek to uznaje że nie zawróci
if(b.vector == b_new.vector) return 0;
else if(b.vector < b_new.vector) return -1;
else return 1;
}
//wywołanie z numerem klatki
//dla przypadków skrajnych dobrać algorytm
//w analizie problemu dać pseudokod
//uszczegółowić przypadki urzycia o algorytm
//nagrać własny film
public void newBus(Bus b_new) {
for (Bus b : c_buses) {
// Czy to jest ten sam bus ?
if(overlapFileter(b_new,b)){
if(b.surface<b_new.surface){
copyBus(b_new,b);
}
}
else if (compareBus(b_new, b)) {
b_new.direction = checkDirection(b_new, b);
copyBus(b_new,b);
//b = b_new; //aktualizacja danych o busie
//System.out.println("Ten sam bus");
return;
}
// Jeśli bus w pamięci był ostatnio aktualizoawny później niż bus_lifetime
if (b_new.life_time - b.life_time > bus_lifetime) {
buses.add(b);
r_buses.add(b);
//System.out.println("Będę usuwał");
// continue;
}
}
c_buses.removeAll(r_buses);
r_buses = new ArrayList<>();
// System.out.println("dodaję busa " + b_new.life_time);
//c_buses.add(b_new); //if not adding new bus
}
//Parser danych z pliku
public void input() {
File file = new File("mpk_output");///home/jakub/darknet/mpk
try {
int line_counter = 0;//licznik klatek
int undefinded_direction = 0; // 0 - standing
try (Scanner sc = new Scanner(file)) {
while (sc.hasNextLine()) {
String i = sc.nextLine();
if(i.contains("FPS")){
line_counter++;
}
if (flag && !i.contains("%")) {
//System.out.println(line_counter);
//System.out.println(i + " " + line_counter);
String[] str = i.split(" ");
//Tworzy busa
Bus b = new Bus(Integer.parseInt(str[0]), Integer.parseInt(str[1]),
Integer.parseInt(str[2]), Integer.parseInt(str[3]), line_counter, undefinded_direction);
// Jeśli nie ma obecnie w pamieci żadnych busów dodaje busa
if (c_buses.isEmpty()) {
c_buses.add(b);
// System.out.println("dodaję busa ");
} else {
// W przypadku gdy są jakieś busy sprawdza czy to nie jest ten sam metodą newBus
newBus(b);
}
flag = false;
}
if (i.contains("bus")) {
//System.out.println(i);
flag = true;
}
}
for (Bus b : c_buses) {
buses.add(b);
}
}
} catch (FileNotFoundException e) {
}
}
} | //Busy które przejechały (zliczone) | import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
/**
*
* @author Jakub Duda, Mateusz Laskowski, Pjoter, Mikis
*
*/
public class Analizator {
int delta = 36; //odległość miedzy środkami
int bus_lifetime = 80; // czas życia busa
ArrayList<Bus> c_buses = new ArrayList<>(); //Busy w pamięci/ pamięta tylko poprzednią klatke
ArrayList<Bus> buses = new ArrayList<>(); //Busy które <SUF>
ArrayList<Bus> r_buses = new ArrayList<>(); // Busy do usunięcia
boolean flag = false;
public static void main(String[] args) throws IOException {
Analizator yolo = new Analizator();
yolo.input();
int i = 0;
String temp;
BufferedWriter writer = new BufferedWriter(new FileWriter("outputAnalizator.txt"));
for (Bus b : yolo.buses) {
i++;
//System.out.println("Bus "+i);
System.out.println("LT "+ b.life_time);
temp = "LT " + b.life_time + "\n";
writer.write(temp);
switch(b.direction) {
case -1: System.out.println("Direction: L -> R");
temp = "Direction: L -> R\n";
break;
case 0: System.out.println("Direction: S");
temp = "Direction: S\n";
break;
case 1: System.out.println("Direction: R -> L");
temp = "Direction: R -> L\n";
break;
default: System.out.println("Direction: undefinded");
temp = "Direction: undefinded\n";
break;
}
writer.write(temp);
}
System.out.println("Bus "+i);
temp = "Bus " + i;
writer.write(temp);
writer.close();
}
// Metoda zwraca wynik czy dany bus_new jest tym samym busem
public boolean compareBus(Bus b_new, Bus b) {
int x = (b_new.center.x - b.center.x) * (b_new.center.x - b.center.x);
int y = (b_new.center.y - b.center.y) * (b_new.center.y - b.center.y);
double d = Math.sqrt((x + y));
//System.out.println("Odległość miedzy busami" + d);
return (d < delta);
}
public boolean overlapFileter(Bus b_new, Bus b){//true gdy się nakłada
//sprawdzenie przypadku nakładania sie obiektów
if(b.life_time==b_new.life_time){
//b to ten wiekszy
if((b.top<=b_new.top) && (b.bottom>=b_new.bottom) && (b.left<=b_new.left)){
return true;
}else{
return false;
}
}
return false;
}
public void copyBus(Bus b_new, Bus b){
b.center = b_new.center;
b.life_time = b_new.life_time;
b.right = b_new.right;
b.top = b_new.top;
b.bottom = b_new.bottom;
b.left = b_new.left;
b.vector = b_new.vector;
b.direction = b_new.direction;
b.surface = b_new.surface;
b.lastFrame = b_new.lastFrame;
}
public int checkDirection(Bus b_new, Bus b) {
// System.out.println("OLD " + b.vector);
// System.out.println("NEW " + b_new.vector);
// if(b.direction != 0) return b.direction; // jeżeli miał już kierunek to uznaje że nie zawróci
if(b.vector == b_new.vector) return 0;
else if(b.vector < b_new.vector) return -1;
else return 1;
}
//wywołanie z numerem klatki
//dla przypadków skrajnych dobrać algorytm
//w analizie problemu dać pseudokod
//uszczegółowić przypadki urzycia o algorytm
//nagrać własny film
public void newBus(Bus b_new) {
for (Bus b : c_buses) {
// Czy to jest ten sam bus ?
if(overlapFileter(b_new,b)){
if(b.surface<b_new.surface){
copyBus(b_new,b);
}
}
else if (compareBus(b_new, b)) {
b_new.direction = checkDirection(b_new, b);
copyBus(b_new,b);
//b = b_new; //aktualizacja danych o busie
//System.out.println("Ten sam bus");
return;
}
// Jeśli bus w pamięci był ostatnio aktualizoawny później niż bus_lifetime
if (b_new.life_time - b.life_time > bus_lifetime) {
buses.add(b);
r_buses.add(b);
//System.out.println("Będę usuwał");
// continue;
}
}
c_buses.removeAll(r_buses);
r_buses = new ArrayList<>();
// System.out.println("dodaję busa " + b_new.life_time);
//c_buses.add(b_new); //if not adding new bus
}
//Parser danych z pliku
public void input() {
File file = new File("mpk_output");///home/jakub/darknet/mpk
try {
int line_counter = 0;//licznik klatek
int undefinded_direction = 0; // 0 - standing
try (Scanner sc = new Scanner(file)) {
while (sc.hasNextLine()) {
String i = sc.nextLine();
if(i.contains("FPS")){
line_counter++;
}
if (flag && !i.contains("%")) {
//System.out.println(line_counter);
//System.out.println(i + " " + line_counter);
String[] str = i.split(" ");
//Tworzy busa
Bus b = new Bus(Integer.parseInt(str[0]), Integer.parseInt(str[1]),
Integer.parseInt(str[2]), Integer.parseInt(str[3]), line_counter, undefinded_direction);
// Jeśli nie ma obecnie w pamieci żadnych busów dodaje busa
if (c_buses.isEmpty()) {
c_buses.add(b);
// System.out.println("dodaję busa ");
} else {
// W przypadku gdy są jakieś busy sprawdza czy to nie jest ten sam metodą newBus
newBus(b);
}
flag = false;
}
if (i.contains("bus")) {
//System.out.println(i);
flag = true;
}
}
for (Bus b : c_buses) {
buses.add(b);
}
}
} catch (FileNotFoundException e) {
}
}
} | t |
3482_3 | Mateoswiatek/JavaZombieGame | 337 | src/spirites/Spirites.java | package spirites;
import javax.swing.*;
import java.awt.*;
public interface Spirites {
/**
* Rysuje postać
* @param g
* @param parent
*/
void draw(Graphics g, JPanel parent);
/**
* Przechodzi do następnej klatki
*/
void next();
/**
* Czy już zniknął z ekranu
* @return
*/
default boolean isVisble(){return true;}
/**
* Czy punkt o współrzędnych _x, _y leży w obszarze postaci -
* czyli czy trafiliśmy ją strzelając w punkcie o tych współrzednych
* @param _x
* @param _y
* @return
*/
default boolean isHit(int _x,int _y){return false;}
/** Czy jest bliżej widza niż other, czyli w naszym przypadku czy jest większy,
* czyli ma wiekszą skalę...
*
* @param other
* @return
*/
default boolean isCloser(Spirites other){return this.getScale() > other.getScale();}
default double getScale() {
return 1.0;
}
} | /**
* Czy punkt o współrzędnych _x, _y leży w obszarze postaci -
* czyli czy trafiliśmy ją strzelając w punkcie o tych współrzednych
* @param _x
* @param _y
* @return
*/ | package spirites;
import javax.swing.*;
import java.awt.*;
public interface Spirites {
/**
* Rysuje postać
* @param g
* @param parent
*/
void draw(Graphics g, JPanel parent);
/**
* Przechodzi do następnej klatki
*/
void next();
/**
* Czy już zniknął z ekranu
* @return
*/
default boolean isVisble(){return true;}
/**
* Czy punkt o <SUF>*/
default boolean isHit(int _x,int _y){return false;}
/** Czy jest bliżej widza niż other, czyli w naszym przypadku czy jest większy,
* czyli ma wiekszą skalę...
*
* @param other
* @return
*/
default boolean isCloser(Spirites other){return this.getScale() > other.getScale();}
default double getScale() {
return 1.0;
}
} | t |
8307_7 | MateuszM02/University | 1,389 | Java/zad2sito/src/code/testy.java | package code;
// java -ea code.testy
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
public final class testy
{
// uruchamia wszystkie testy
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, InvocationTargetException
{
uruchom();
}
public static void uruchom() throws NoSuchMethodException, SecurityException, IllegalAccessException, InvocationTargetException
{
for(int i = 0; i <= 11; i++)
{
testy.class.getMethod("testCzyPierwsza"+i).invoke(null);
}
for(int i = 0; i <= 7; i++)
{
testy.class.getMethod("testNaCzynnikiPierwsze"+i).invoke(null);
}
}
// testy metody czyPierwsza -------------------------------------------------------------------
public static void testCzyPierwsza0()
{
assert !LiczbyPierwsze.czyPierwsza(0);
}
public static void testCzyPierwsza1()
{
assert !LiczbyPierwsze.czyPierwsza(1);
}
public static void testCzyPierwsza2()
{
assert LiczbyPierwsze.czyPierwsza(2);
}
public static void testCzyPierwsza3()
{
assert !LiczbyPierwsze.czyPierwsza(4); // 2 * 2
}
public static void testCzyPierwsza4()
{
assert LiczbyPierwsze.czyPierwsza(5);
}
public static void testCzyPierwsza5()
{
assert LiczbyPierwsze.czyPierwsza(29);
}
public static void testCzyPierwsza6()
{
assert !LiczbyPierwsze.czyPierwsza(529); // 23 * 23
}
public static void testCzyPierwsza7()
{
assert LiczbyPierwsze.czyPierwsza(2137);
}
public static void testCzyPierwsza8()
{
assert !LiczbyPierwsze.czyPierwsza(3721); // 61 * 61
}
public static void testCzyPierwsza9()
{
assert LiczbyPierwsze.czyPierwsza(10007);
}
public static void testCzyPierwsza10()
{
assert !LiczbyPierwsze.czyPierwsza(-5); // ujemne nigdy nie sa pierwsze
}
public static void testCzyPierwsza11()
{
assert LiczbyPierwsze.czyPierwsza(9223372036854775783L); // najwieksza liczba pierwsza w long
}
// testy metody naCzynnikiPierwsze ------------------------------------------------------------
public static void testNaCzynnikiPierwsze0()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(0), new long[]{0});
}
public static void testNaCzynnikiPierwsze1()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(-1), new long[]{-1});
}
public static void testNaCzynnikiPierwsze2()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(-60), new long[]{-1, 2, 2, 3, 5});
}
public static void testNaCzynnikiPierwsze3()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(8), new long[]{2, 2, 2});
}
public static void testNaCzynnikiPierwsze4()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(10), new long[]{2, 5});
}
public static void testNaCzynnikiPierwsze5()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(169), new long[]{13, 13});
}
public static void testNaCzynnikiPierwsze6()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(770), new long[]{2, 5, 7, 11});
}
public static void testNaCzynnikiPierwsze7()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(-770), new long[]{-1, 2, 5, 7, 11});
}
}
| // najwieksza liczba pierwsza w long
| package code;
// java -ea code.testy
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
public final class testy
{
// uruchamia wszystkie testy
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, InvocationTargetException
{
uruchom();
}
public static void uruchom() throws NoSuchMethodException, SecurityException, IllegalAccessException, InvocationTargetException
{
for(int i = 0; i <= 11; i++)
{
testy.class.getMethod("testCzyPierwsza"+i).invoke(null);
}
for(int i = 0; i <= 7; i++)
{
testy.class.getMethod("testNaCzynnikiPierwsze"+i).invoke(null);
}
}
// testy metody czyPierwsza -------------------------------------------------------------------
public static void testCzyPierwsza0()
{
assert !LiczbyPierwsze.czyPierwsza(0);
}
public static void testCzyPierwsza1()
{
assert !LiczbyPierwsze.czyPierwsza(1);
}
public static void testCzyPierwsza2()
{
assert LiczbyPierwsze.czyPierwsza(2);
}
public static void testCzyPierwsza3()
{
assert !LiczbyPierwsze.czyPierwsza(4); // 2 * 2
}
public static void testCzyPierwsza4()
{
assert LiczbyPierwsze.czyPierwsza(5);
}
public static void testCzyPierwsza5()
{
assert LiczbyPierwsze.czyPierwsza(29);
}
public static void testCzyPierwsza6()
{
assert !LiczbyPierwsze.czyPierwsza(529); // 23 * 23
}
public static void testCzyPierwsza7()
{
assert LiczbyPierwsze.czyPierwsza(2137);
}
public static void testCzyPierwsza8()
{
assert !LiczbyPierwsze.czyPierwsza(3721); // 61 * 61
}
public static void testCzyPierwsza9()
{
assert LiczbyPierwsze.czyPierwsza(10007);
}
public static void testCzyPierwsza10()
{
assert !LiczbyPierwsze.czyPierwsza(-5); // ujemne nigdy nie sa pierwsze
}
public static void testCzyPierwsza11()
{
assert LiczbyPierwsze.czyPierwsza(9223372036854775783L); // najwieksza liczba <SUF>
}
// testy metody naCzynnikiPierwsze ------------------------------------------------------------
public static void testNaCzynnikiPierwsze0()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(0), new long[]{0});
}
public static void testNaCzynnikiPierwsze1()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(-1), new long[]{-1});
}
public static void testNaCzynnikiPierwsze2()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(-60), new long[]{-1, 2, 2, 3, 5});
}
public static void testNaCzynnikiPierwsze3()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(8), new long[]{2, 2, 2});
}
public static void testNaCzynnikiPierwsze4()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(10), new long[]{2, 5});
}
public static void testNaCzynnikiPierwsze5()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(169), new long[]{13, 13});
}
public static void testNaCzynnikiPierwsze6()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(770), new long[]{2, 5, 7, 11});
}
public static void testNaCzynnikiPierwsze7()
{
assert Arrays.equals(LiczbyPierwsze.naCzynnikiPierwsze(-770), new long[]{-1, 2, 5, 7, 11});
}
}
| t |
8173_1 | MateuszSochacki/StrazowaniePZ | 843 | src/main/java/com/cinema/model/MovieEntity.java | package com.cinema.model;
import javax.persistence.*;
import java.sql.Date;
import java.util.List;
import java.util.Set;
/**
* Created by msoch_000 on 02-05-2017.
* A class that stores all the information about the movies in the database.
*/
@Entity
public class MovieEntity {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id_movie")
private Integer idMovie;
private String title;
private Integer duration;
private String director;
private Date releaseDate;
private String description;
private byte[] cover;
private String trailer;
//fetch musi być ustawione na eager, dzięki czemu pobiera też inne encje które wykorzystuje, w tym przypadku CategoryEntity
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinTable(name = "movie_category", joinColumns = {@JoinColumn(name = "id_movie")}, inverseJoinColumns = {@JoinColumn(columnDefinition = "id_category")})
private List<CategoryEntity> categoryEntities;
@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
private AgeRatingEntity ageRatingEntities;
public AgeRatingEntity getAgeRatingEntities() {
return ageRatingEntities;
}
public void setAgeRatingEntities(AgeRatingEntity ageRatingEntities) {
this.ageRatingEntities = ageRatingEntities;
}
public Integer getIdMovie() {
return idMovie;
}
public void setIdMovie(Integer idMovie) {
this.idMovie = idMovie;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Integer getDuration() {
return duration;
}
public void setDuration(Integer duration) {
this.duration = duration;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public Date getReleaseDate() {
return releaseDate;
}
public void setReleaseDate(Date releaseDate) {
this.releaseDate = releaseDate;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public List<CategoryEntity> getCategoryEntities() {
return categoryEntities;
}
public void setCategoryEntity(List<CategoryEntity> categoryEntities) {
this.categoryEntities = categoryEntities;
}
@Basic
@Column(name = "COVER", nullable = true)
public byte[] getCover() {
return cover;
}
public void setCover(byte[] cover) {
this.cover = cover;
}
public String getTrailer() {
return trailer;
}
public void setTrailer(String trailer) {
this.trailer = trailer;
}
}
| //fetch musi być ustawione na eager, dzięki czemu pobiera też inne encje które wykorzystuje, w tym przypadku CategoryEntity | package com.cinema.model;
import javax.persistence.*;
import java.sql.Date;
import java.util.List;
import java.util.Set;
/**
* Created by msoch_000 on 02-05-2017.
* A class that stores all the information about the movies in the database.
*/
@Entity
public class MovieEntity {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id_movie")
private Integer idMovie;
private String title;
private Integer duration;
private String director;
private Date releaseDate;
private String description;
private byte[] cover;
private String trailer;
//fetch musi <SUF>
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinTable(name = "movie_category", joinColumns = {@JoinColumn(name = "id_movie")}, inverseJoinColumns = {@JoinColumn(columnDefinition = "id_category")})
private List<CategoryEntity> categoryEntities;
@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
private AgeRatingEntity ageRatingEntities;
public AgeRatingEntity getAgeRatingEntities() {
return ageRatingEntities;
}
public void setAgeRatingEntities(AgeRatingEntity ageRatingEntities) {
this.ageRatingEntities = ageRatingEntities;
}
public Integer getIdMovie() {
return idMovie;
}
public void setIdMovie(Integer idMovie) {
this.idMovie = idMovie;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Integer getDuration() {
return duration;
}
public void setDuration(Integer duration) {
this.duration = duration;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public Date getReleaseDate() {
return releaseDate;
}
public void setReleaseDate(Date releaseDate) {
this.releaseDate = releaseDate;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public List<CategoryEntity> getCategoryEntities() {
return categoryEntities;
}
public void setCategoryEntity(List<CategoryEntity> categoryEntities) {
this.categoryEntities = categoryEntities;
}
@Basic
@Column(name = "COVER", nullable = true)
public byte[] getCover() {
return cover;
}
public void setCover(byte[] cover) {
this.cover = cover;
}
public String getTrailer() {
return trailer;
}
public void setTrailer(String trailer) {
this.trailer = trailer;
}
}
| t |
8131_2 | MateuszZaniewski/LearningJava | 530 | PrimitiveCompare.java | public class PrimitiveCompare {
public static void main(String[] args) {
int a = 3;
System.out.println("A: " + a);
int b = 3;
System.out.println("B: " + b);
System.out.println(a == b); // true
System.out.println(a == 3); // true
System.out.println(a == '3'); // false
Integer c = 300;
Integer d = 300;
// Za kazdym razem gdy tworzymy nowy Integer powyżej 128 to rezerowana jest dla niego nowe miejsce w stosie!
// Gdy weżmiemy mniejsza liczbę niż 128 to obie liczby będą miały te same referencje w stosie i będą takie same!
System.out.println(c == d); // false
// W tym wypadku obie liczby są takie same, poniważ mają zarezerwowaną te same miejsce pamięci!
Integer e = 100;
Integer f = 100;
System.out.println(e == f); // true
// Metodą 'equals' sprawdza realną wartość zmiennej, nie patrzy na to w którym miejscu jest ona zarezerwowana z stosie, dlatego też obie c jest równe d!
System.out.println(c.equals(d));
// Tworzymy dwa string, które posiadają taką samą referncję w stosie dlatego są równoważne.
String s1 = "Cat";
String s2 = "Cat";
System.out.println(s1 == s2); // true
String s3 = new String("Cat");
// Tworzy się nowy string w String poolu i rezerwuje nowy adres w pamieci stosu, dlatego wartości nie są takie same.
System.out.println(s1 == s3); //false
}
}
| // W tym wypadku obie liczby są takie same, poniważ mają zarezerwowaną te same miejsce pamięci! | public class PrimitiveCompare {
public static void main(String[] args) {
int a = 3;
System.out.println("A: " + a);
int b = 3;
System.out.println("B: " + b);
System.out.println(a == b); // true
System.out.println(a == 3); // true
System.out.println(a == '3'); // false
Integer c = 300;
Integer d = 300;
// Za kazdym razem gdy tworzymy nowy Integer powyżej 128 to rezerowana jest dla niego nowe miejsce w stosie!
// Gdy weżmiemy mniejsza liczbę niż 128 to obie liczby będą miały te same referencje w stosie i będą takie same!
System.out.println(c == d); // false
// W tym <SUF>
Integer e = 100;
Integer f = 100;
System.out.println(e == f); // true
// Metodą 'equals' sprawdza realną wartość zmiennej, nie patrzy na to w którym miejscu jest ona zarezerwowana z stosie, dlatego też obie c jest równe d!
System.out.println(c.equals(d));
// Tworzymy dwa string, które posiadają taką samą referncję w stosie dlatego są równoważne.
String s1 = "Cat";
String s2 = "Cat";
System.out.println(s1 == s2); // true
String s3 = new String("Cat");
// Tworzy się nowy string w String poolu i rezerwuje nowy adres w pamieci stosu, dlatego wartości nie są takie same.
System.out.println(s1 == s3); //false
}
}
| t |
6937_1 | MattWroclaw/DesignPatterns | 108 | src/main/java/pl/sdacademy/designpatterns/observer/Observer.java | package pl.sdacademy.designpatterns.observer;
public abstract class Observer {
protected Subject subject; //protected żeby był widoczny w package w ContreValueObserver
public Observer(Subject subject) {
this.subject = subject;
subject.subscribe(this); //sam siebie chcę zasubstrybkować do tematu
}
public abstract void update();
}
| //sam siebie chcę zasubstrybkować do tematu | package pl.sdacademy.designpatterns.observer;
public abstract class Observer {
protected Subject subject; //protected żeby był widoczny w package w ContreValueObserver
public Observer(Subject subject) {
this.subject = subject;
subject.subscribe(this); //sam siebie <SUF>
}
public abstract void update();
}
| t |
10069_2 | MattWroclaw/Hibernate_JPQL_sciagawka | 2,071 | src/main/java/sda/hibernate/przyklad1.java | package sda.hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import sda.hibernate.entity.Klient;
import sda.hibernate.entity.Umowa;
import java.sql.Date;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
public class przyklad1 {
public static void main(String[] args) {
insertData();
Session session = HibernateUtil.getSessionFactory().openSession();
List<Klient> klienci = new ArrayList<>();
List<Umowa> umowy = new ArrayList<>();
//odpowiednik zapytania SELECT * FROM klient , czyli <SELECT *> jest domyślnie
// to są dwa równoważne zapytania, pierwsze to forma skócona
klienci = session.createQuery("FROM Klient", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k", Klient.class).getResultList();
for (Klient kl :klienci){
// System.out.println(kl.toString());
System.out.println("**KLIENT** "+kl.toString());
for (Umowa um :kl.getUmowy()){
System.out.println("*umowa*:"+ um.toString());
}
}
//klauzula WHERE,
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie in ('Jan','Robert')", Klient.class).getResultList();
for(Klient kl :klienci){
System.out.println(">>Roberty i Jany: "+kl.toString());
}
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.id between 1 and 10", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.nazwisko is null", Klient.class).getResultList();
for(Klient kl :klienci){
System.out.println(">>Nazwisko NULL: "+kl.toString());
}
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.nazwisko is not null", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie LIKE 'A%'", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie NOT LIKE 'R%'", Klient.class).getResultList();
// tutaj mamy że chcemy znaleść jakąś frazę. Nie można %parametr%, tylko właśnie concatem. % dowolna ilość znaków
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie LIKE CONCAT('%',:naz,'%')", Klient.class).setParameter("naz","We").getResultList();
for(Klient kl :klienci){
System.out.println("** w imie ma być parametr :naz = \"we\": "+kl.toString());
}
// podkreślenie _ to jest jeden znak
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie LIKE '_la'", Klient.class).getResultList();
// robimy 'or' albo 'and' nie & ani ||
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie ='Ola' or k.imie='Ala'", Klient.class).getResultList();
// tutaj korzystamy z właśności listy, Lista ma l.size
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.umowy.size>10", Klient.class).getResultList();
//select z warunkiem z podklasy
// umowa też ma pole Klient
umowy = session.createQuery("SELECT u FROM Umowa u WHERE u.klient.imie='Ala'", Umowa.class).getResultList();
//select z konkretnymi kolumnami SELECT imie, nazwisko FROM klient
Object klienciImieNazwisko = session.createQuery("SELECT k.imie, k.nazwisko FROM Klient k").getResultList();
//funkcje agregujace
//Count zwraca liczbe wierszy
Long count = session.createQuery("SELECT COUNT(k) FROM Klient k", Long.class).getSingleResult();
System.out.println("** Liczba klientów: "+count);
//Count zwraca maksymala liczbe
Long maxIdUmowy = session.createQuery("SELECT MAX(u.id) FROM Umowa u", Long.class).getSingleResult();
System.out.println("** Max nr umowy:"+ maxIdUmowy);
//Count zwraca minimalna liczbe
Long minIdUmowy = session.createQuery("SELECT MIN(u.id) FROM Umowa u", Long.class).getSingleResult();
//Count zwraca srednia
Double avg = session.createQuery("SELECT AVG(k.id) FROM Klient k", Double.class).getSingleResult();
System.out.println("*********** Laczenie JOIN **********");
//laczenie JOIN
klienci = session.createQuery("SELECT k FROM Klient k JOIN FETCH k.umowy u ", Klient.class).getResultList();
System.out.println("** Łączy klienta z umową: ");
for (Klient kl :klienci){
System.out.println("*Klient:"+ kl.toString());
}
klienci = session.createQuery("SELECT DISTINCT k FROM Klient k JOIN FETCH k.umowy u ", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k JOIN k.umowy u ", Klient.class).getResultList();
//ustawianie maksymalnej liczby rekordow
klienci = session.createQuery("SELECT k FROM Klient k", Klient.class).setMaxResults(5).getResultList();
//ustawianie parametrow
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie=:imie", Klient.class).setParameter("imie", "Adam").getResultList();
session.close();
session = HibernateUtil.getSessionFactory().openSession();
Transaction tr = session.beginTransaction();
//update z parametrami
// tutaj nazwa to jest ta nazwa z encji, nie z tabelki SQL
session.createQuery("UPDATE Umowa u SET u.tytul=:tytul WHERE u.id=:id").setParameter("tytul", "nowyTytul").setParameter("id", 3L).executeUpdate();
tr.commit();
session.close();
}
public static void insertData() {
Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
String imiona[] = {"Adam", "Ewa", "Stanislaw", "Szymon", "Ola", "Ala", "Robert", "Marcin", "Karolina", "Sylwia", "Ewelina", "Kamil", "Sandra", "Wojtek", "Katarzyna", "Slawek", "Kamila"};
String nazwiska[] = {"Nowak", "Kowalski", "Mickiewicz", "Slowacki", "Duda", "Trampek", "Wilk", "Szybki", "Wesoly", "Smutny", "Mily", "Nowy", "Maly", null, null, null, null};
for (int i = 0; i < imiona.length; i++) {
Klient klinet = new Klient(imiona[i], nazwiska[i]);
session.persist(klinet);
for (int j = 1; j < i+2; j++) {
Umowa umowa = new Umowa("umowa" + j, Date.valueOf(LocalDate.now()), klinet);
session.persist(umowa);
}
}
session.flush();
session.close();
}
}
| // tutaj mamy że chcemy znaleść jakąś frazę. Nie można %parametr%, tylko właśnie concatem. % dowolna ilość znaków | package sda.hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import sda.hibernate.entity.Klient;
import sda.hibernate.entity.Umowa;
import java.sql.Date;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
public class przyklad1 {
public static void main(String[] args) {
insertData();
Session session = HibernateUtil.getSessionFactory().openSession();
List<Klient> klienci = new ArrayList<>();
List<Umowa> umowy = new ArrayList<>();
//odpowiednik zapytania SELECT * FROM klient , czyli <SELECT *> jest domyślnie
// to są dwa równoważne zapytania, pierwsze to forma skócona
klienci = session.createQuery("FROM Klient", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k", Klient.class).getResultList();
for (Klient kl :klienci){
// System.out.println(kl.toString());
System.out.println("**KLIENT** "+kl.toString());
for (Umowa um :kl.getUmowy()){
System.out.println("*umowa*:"+ um.toString());
}
}
//klauzula WHERE,
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie in ('Jan','Robert')", Klient.class).getResultList();
for(Klient kl :klienci){
System.out.println(">>Roberty i Jany: "+kl.toString());
}
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.id between 1 and 10", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.nazwisko is null", Klient.class).getResultList();
for(Klient kl :klienci){
System.out.println(">>Nazwisko NULL: "+kl.toString());
}
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.nazwisko is not null", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie LIKE 'A%'", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie NOT LIKE 'R%'", Klient.class).getResultList();
// tutaj mamy <SUF>
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie LIKE CONCAT('%',:naz,'%')", Klient.class).setParameter("naz","We").getResultList();
for(Klient kl :klienci){
System.out.println("** w imie ma być parametr :naz = \"we\": "+kl.toString());
}
// podkreślenie _ to jest jeden znak
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie LIKE '_la'", Klient.class).getResultList();
// robimy 'or' albo 'and' nie & ani ||
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie ='Ola' or k.imie='Ala'", Klient.class).getResultList();
// tutaj korzystamy z właśności listy, Lista ma l.size
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.umowy.size>10", Klient.class).getResultList();
//select z warunkiem z podklasy
// umowa też ma pole Klient
umowy = session.createQuery("SELECT u FROM Umowa u WHERE u.klient.imie='Ala'", Umowa.class).getResultList();
//select z konkretnymi kolumnami SELECT imie, nazwisko FROM klient
Object klienciImieNazwisko = session.createQuery("SELECT k.imie, k.nazwisko FROM Klient k").getResultList();
//funkcje agregujace
//Count zwraca liczbe wierszy
Long count = session.createQuery("SELECT COUNT(k) FROM Klient k", Long.class).getSingleResult();
System.out.println("** Liczba klientów: "+count);
//Count zwraca maksymala liczbe
Long maxIdUmowy = session.createQuery("SELECT MAX(u.id) FROM Umowa u", Long.class).getSingleResult();
System.out.println("** Max nr umowy:"+ maxIdUmowy);
//Count zwraca minimalna liczbe
Long minIdUmowy = session.createQuery("SELECT MIN(u.id) FROM Umowa u", Long.class).getSingleResult();
//Count zwraca srednia
Double avg = session.createQuery("SELECT AVG(k.id) FROM Klient k", Double.class).getSingleResult();
System.out.println("*********** Laczenie JOIN **********");
//laczenie JOIN
klienci = session.createQuery("SELECT k FROM Klient k JOIN FETCH k.umowy u ", Klient.class).getResultList();
System.out.println("** Łączy klienta z umową: ");
for (Klient kl :klienci){
System.out.println("*Klient:"+ kl.toString());
}
klienci = session.createQuery("SELECT DISTINCT k FROM Klient k JOIN FETCH k.umowy u ", Klient.class).getResultList();
klienci = session.createQuery("SELECT k FROM Klient k JOIN k.umowy u ", Klient.class).getResultList();
//ustawianie maksymalnej liczby rekordow
klienci = session.createQuery("SELECT k FROM Klient k", Klient.class).setMaxResults(5).getResultList();
//ustawianie parametrow
klienci = session.createQuery("SELECT k FROM Klient k WHERE k.imie=:imie", Klient.class).setParameter("imie", "Adam").getResultList();
session.close();
session = HibernateUtil.getSessionFactory().openSession();
Transaction tr = session.beginTransaction();
//update z parametrami
// tutaj nazwa to jest ta nazwa z encji, nie z tabelki SQL
session.createQuery("UPDATE Umowa u SET u.tytul=:tytul WHERE u.id=:id").setParameter("tytul", "nowyTytul").setParameter("id", 3L).executeUpdate();
tr.commit();
session.close();
}
public static void insertData() {
Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
String imiona[] = {"Adam", "Ewa", "Stanislaw", "Szymon", "Ola", "Ala", "Robert", "Marcin", "Karolina", "Sylwia", "Ewelina", "Kamil", "Sandra", "Wojtek", "Katarzyna", "Slawek", "Kamila"};
String nazwiska[] = {"Nowak", "Kowalski", "Mickiewicz", "Slowacki", "Duda", "Trampek", "Wilk", "Szybki", "Wesoly", "Smutny", "Mily", "Nowy", "Maly", null, null, null, null};
for (int i = 0; i < imiona.length; i++) {
Klient klinet = new Klient(imiona[i], nazwiska[i]);
session.persist(klinet);
for (int j = 1; j < i+2; j++) {
Umowa umowa = new Umowa("umowa" + j, Date.valueOf(LocalDate.now()), klinet);
session.persist(umowa);
}
}
session.flush();
session.close();
}
}
| t |
3864_3 | MattWroclaw/Struktury_Danych_All_in_one | 856 | Java/Java/Kwadraty.java | // Kompilacja i użycie:
// javac Kwadraty.java
// java Kwadraty
import java.awt.*;
import javax.swing.*;
public class Kwadraty extends Canvas {
// prostokątny komponent pozwalający na rysowanie i przechwytywanie zdarzeń
// Użyjemy możliwości klasy bazowej Canvas
public void rysuj_kwadraty (int n, int lg, int x, int y){// Algorytm rysujący kwadraty
// n musi być parzyste
Graphics gc=this.getGraphics();// pobierz kontekst graficzny
if (n>0) {
gc.drawLine(x, y, x+lg,y);
gc.drawLine(x+lg,y, x+lg,y+lg);
gc.drawLine(x+lg,y+lg, x,y+lg);
gc.drawLine(x,y+lg, x,y+lg/2);
gc.drawLine(x,y+lg/2, x+lg/2,y+lg);
gc.drawLine(x+lg/2, y+lg, x+lg,y+lg/2);
gc.drawLine(x+lg, y+lg/2, x+lg/2,y);
gc.drawLine(x+lg/2, y, x+lg/4,y+lg/4);
rysuj_kwadraty(n-1,lg/2, x+lg/4,y+lg/4);
gc.drawLine(x+lg/4, y+lg/4, x,y+lg/2);
gc.drawLine(x,y+lg/2, x,y);
}
}
// Nadpisując metodę paint możemy samodzielnie coś narysować
public void paint(Graphics graphics) {
int szer=this.getWidth(); // szerokość komponentu
// Narysujmy obiekt poczynajc od punktu (15, 15), tak, aby zajął większość obszaru okna
rysuj_kwadraty(6, 380, 15, 15);
}
// wywołujemy algorytm
public static void main(String[] args) {
// tworzymy obiekt klasy Kwadraty w formie płótna do rysowania
Kwadraty kw = new Kwadraty();
// Tworzymy ono aplikacji
JFrame f = new JFrame("Kwadraty rekurencyjne");
// w praktyce klasa JFrame jest zazwyczaj nadpisywana przez klasę użytkownika poprzez mechanizm
// dziedziczenia i poniższe polecenia powinny być ukryte w konstruktorach lub metodach tej klasy
f.setLocation(100, 100); // pozycja okna
f.setSize(450, 450); // rozmiar okna
// Zniszcz obiekt okna po zamknięciu okna
f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
f.getContentPane().add(kw);
f.setVisible(true);
}
}
| // Algorytm rysujący kwadraty | // Kompilacja i użycie:
// javac Kwadraty.java
// java Kwadraty
import java.awt.*;
import javax.swing.*;
public class Kwadraty extends Canvas {
// prostokątny komponent pozwalający na rysowanie i przechwytywanie zdarzeń
// Użyjemy możliwości klasy bazowej Canvas
public void rysuj_kwadraty (int n, int lg, int x, int y){// Algorytm rysujący <SUF>
// n musi być parzyste
Graphics gc=this.getGraphics();// pobierz kontekst graficzny
if (n>0) {
gc.drawLine(x, y, x+lg,y);
gc.drawLine(x+lg,y, x+lg,y+lg);
gc.drawLine(x+lg,y+lg, x,y+lg);
gc.drawLine(x,y+lg, x,y+lg/2);
gc.drawLine(x,y+lg/2, x+lg/2,y+lg);
gc.drawLine(x+lg/2, y+lg, x+lg,y+lg/2);
gc.drawLine(x+lg, y+lg/2, x+lg/2,y);
gc.drawLine(x+lg/2, y, x+lg/4,y+lg/4);
rysuj_kwadraty(n-1,lg/2, x+lg/4,y+lg/4);
gc.drawLine(x+lg/4, y+lg/4, x,y+lg/2);
gc.drawLine(x,y+lg/2, x,y);
}
}
// Nadpisując metodę paint możemy samodzielnie coś narysować
public void paint(Graphics graphics) {
int szer=this.getWidth(); // szerokość komponentu
// Narysujmy obiekt poczynajc od punktu (15, 15), tak, aby zajął większość obszaru okna
rysuj_kwadraty(6, 380, 15, 15);
}
// wywołujemy algorytm
public static void main(String[] args) {
// tworzymy obiekt klasy Kwadraty w formie płótna do rysowania
Kwadraty kw = new Kwadraty();
// Tworzymy ono aplikacji
JFrame f = new JFrame("Kwadraty rekurencyjne");
// w praktyce klasa JFrame jest zazwyczaj nadpisywana przez klasę użytkownika poprzez mechanizm
// dziedziczenia i poniższe polecenia powinny być ukryte w konstruktorach lub metodach tej klasy
f.setLocation(100, 100); // pozycja okna
f.setSize(450, 450); // rozmiar okna
// Zniszcz obiekt okna po zamknięciu okna
f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
f.getContentPane().add(kw);
f.setVisible(true);
}
}
| t |
7707_4 | MattWroclaw/Testowanie_TDD | 560 | src/main/java/Pet.java | /**
* Zwierzątko
*/
public class Pet {
/**
* Imię
*/
private String name;
/**
* Waga
*/
private double weight;
/**
* Wysokość
*/
private double height;
/**
* Wiek
*/
private int age;
/**
* @return Wiek zwierzątka
*/
public int getAge() {
return age;
}
/**
* @param age Ustawia wiek zwierzątka
*/
public void setAge(int age) {
this.age = age;
}
/**
* @return Wysokość zwierzątka
*/
public double getHeight() {
return height;
}
/**
* @param height Ustawai wysokość zwierzątka
*/
public void setHeight(double height) {
this.height = height;
}
/**
* @return Waga zwierzątka
*/
public double getWeight() {
return weight;
}
/**
* @param weight Ustawia wagę zwierzątka
*/
public void setWeight(double weight) {
this.weight = weight;
}
/**
* @return Imię zwierzątka
*/
public String getName() {
try { // specjalnie robimy, żeby trzeba czekać, bo za pomocą mocków będziemy to sprawdzć
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return name;
}
/**
* @param name Ustawia imię zwierzątka
*/
public void setName(String name) {
this.name = name;
}
public void sleep(int hrs){
weight = weight*0.5*hrs;
}
public void feed(int kg){
weight = weight+kg;
}
public int getBMI(){
int bmi = (int) (weight/height);
return bmi;
}
}
| /**
* @return Wiek zwierzątka
*/ | /**
* Zwierzątko
*/
public class Pet {
/**
* Imię
*/
private String name;
/**
* Waga
*/
private double weight;
/**
* Wysokość
*/
private double height;
/**
* Wiek
*/
private int age;
/**
* @return Wiek zwierzątka <SUF>*/
public int getAge() {
return age;
}
/**
* @param age Ustawia wiek zwierzątka
*/
public void setAge(int age) {
this.age = age;
}
/**
* @return Wysokość zwierzątka
*/
public double getHeight() {
return height;
}
/**
* @param height Ustawai wysokość zwierzątka
*/
public void setHeight(double height) {
this.height = height;
}
/**
* @return Waga zwierzątka
*/
public double getWeight() {
return weight;
}
/**
* @param weight Ustawia wagę zwierzątka
*/
public void setWeight(double weight) {
this.weight = weight;
}
/**
* @return Imię zwierzątka
*/
public String getName() {
try { // specjalnie robimy, żeby trzeba czekać, bo za pomocą mocków będziemy to sprawdzć
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return name;
}
/**
* @param name Ustawia imię zwierzątka
*/
public void setName(String name) {
this.name = name;
}
public void sleep(int hrs){
weight = weight*0.5*hrs;
}
public void feed(int kg){
weight = weight+kg;
}
public int getBMI(){
int bmi = (int) (weight/height);
return bmi;
}
}
| t |
3141_2 | MattWroclaw/zadania_Obiektowe | 2,576 | src/main/java/com/model/day1/game/Waz.java | package com.model.day1.game;
import java.util.Scanner;
public class Waz {
private int wielkosc;
private char[][] mapa;
private Gracz gracz;
private int[][] tabPoz;
// konstruktor
public Waz(int wielkosc, Gracz gracz) {
this.wielkosc = wielkosc;
this.mapa = new char[wielkosc][wielkosc];
this.gracz = gracz;
}
public void emptyMap() {
for (int i = 0; i < mapa.length; i++) {
for (int j = 0; j < mapa.length; j++) {
if (((i == 0) || i == (mapa.length - 1) || (j == 0) || (j == (mapa.length - 1)))) {
mapa[i][j] = '&';
} else {
mapa[i][j] = '.';
}
}
}
}
public void fillMap() {
for (int i = 0; i < mapa.length; i++) {
for (int j = 0; j < mapa.length; j++) {
if (((i == 0) || i == (mapa.length - 1) || (j == 0) || (j == (mapa.length - 1)))) {
mapa[i][j] = '&';
} else {
mapa[i][j] = '.';
}
}
}
// tutaj można dodawać pozycje!
// mapa[1][1]='q';
// mapa[2][2]='q';
// mapa[3][3]='q';
ustawPozPionka();
}
public void printMap() {
for (int i = 0; i < mapa.length; i++) {
for (int j = 0; j < mapa.length; j++) {
System.out.print(mapa[i][j]);
}
System.out.println();
}
}
public void ustawPozPionka() {
mapa[gracz.getX()][gracz.getY()] = gracz.getSymbol();
}
public void ruchy() throws InterruptedException {
Scanner input = new Scanner(System.in);
// licznik ruchów
int licznikRuchow = 1;
int[][] tabPoz = new int[100][10];
// pytanie użytkownika o ruch
System.out.println("Ruch: \ngóra w\ndół s\nLewo a\nPrawo d\nWyjście x");
String wybor = "";
boolean flaga = false;
do {
wybor = input.nextLine();
switch (wybor) {
case "w":
try {
gracz.setX(gracz.getX() - 1);
for (int i = 2; i <= licznikRuchow; i++) {
if (
mapa[tabPoz[i][0]][tabPoz[i][1]] == mapa[(gracz.getX())][gracz.getY()]) {
System.out.println("Ugryzłeś się w zad! :P");
wybor = "x";
break;
}
}
fillMap();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Wychodzisz poza planszę \n daję Cię na środek");
gracz.setX(5);
gracz.setY(5);
}
System.out.println("zapamiętanie do tabli");
// zapamiętanie pozcji do tabeli
tabPoz[licznikRuchow][0] = (gracz.getX());
tabPoz[licznikRuchow][1] = (gracz.getY());
fillMap();
System.out.println("pionek tu był");
// to są pozycje na których pionek już był
for (int i = 0; i <= licznikRuchow; i++) {
mapa[tabPoz[i][0]][tabPoz[i][1]] = gracz.getSymbol();
}
// ustawPozPionka();
System.out.println("d!");
System.out.println("przed print");
printMap();
Thread.sleep(1000);
break;
// *************** KONIEC RUCHU "w" GÓRA ****************
case "s":
try {
gracz.setX(gracz.getX() + 1);
for (int i = 2; i <= licznikRuchow; i++) {
if (
mapa[tabPoz[i][0]][tabPoz[i][1]] == mapa[(gracz.getX())][gracz.getY()]) {
System.out.println("Ugryzłeś się w zad! :P");
wybor="x";
break;
}
break;
}
fillMap();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Wychodzisz poza planszę \n daję Cię na środek");
gracz.setX(5);
gracz.setY(5);
}
tabPoz[licznikRuchow][0] = (gracz.getX()); //tapo[0][0]=5
tabPoz[licznikRuchow][1] = (gracz.getY());
fillMap();
for (int i = 0; i <= licznikRuchow; i++) {
mapa[tabPoz[i][0]][tabPoz[i][1]] = gracz.getSymbol();
}
// ustawPozPionka();
printMap();
break;
// ******************LEWO********************
case "a":
try {
gracz.setY(gracz.getY() - 1);
for (int i = 2; i <= licznikRuchow; i++) {
if (
mapa[tabPoz[i][0]][tabPoz[i][1]] == mapa[(gracz.getX())][gracz.getY()]) {
System.out.println("Ugryzłeś się w zad! :P");
wybor="x";
break;
}
break;
}
fillMap();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Wychodzisz poza planszę \n daję Cię na środek");
gracz.setX(5);
gracz.setY(5);
}
tabPoz[licznikRuchow][0] = (gracz.getX()); //tapo[0][0]=5
tabPoz[licznikRuchow][1] = (gracz.getY());
fillMap();
for (int i = 0; i <= licznikRuchow; i++) {
mapa[tabPoz[i][0]][tabPoz[i][1]] = gracz.getSymbol();
}
// ustawPozPionka();
printMap();
break;
// *******************PRAWO******************************
case "d":
try {
gracz.setY(gracz.getY() + 1);
for (int i = 2; i <= licznikRuchow; i++) {
if (
mapa[tabPoz[i][0]][tabPoz[i][1]] == mapa[(gracz.getX())][gracz.getY()]) // sprawdza, czy taka pozycja już wystąpiła
{
System.out.println("Ugryzłeś się w zad! :P"); //komunikat jak weszło się na zajęte pole
wybor="x";
break;
}
}
fillMap();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Wychodzisz poza planszę \n daję Cię na środek");
gracz.setX(5);
gracz.setY(5);
}
tabPoz[licznikRuchow][0] = (gracz.getX()); //tapo[0][0]=5
tabPoz[licznikRuchow][1] = (gracz.getY());
fillMap();
for (int i = 0; i <= licznikRuchow; i++) {
mapa[tabPoz[i][0]][tabPoz[i][1]] = gracz.getSymbol();
}
// ustawPozPionka();
printMap();
break;
}
licznikRuchow++;
} while (!wybor.equalsIgnoreCase("x"));
}
public static void main(String[] args) throws InterruptedException {
Gracz gracz = new Gracz(5, 5, 'x');
Waz waz = new Waz(10, gracz);
waz.ruchy();
}
}
| // zapamiętanie pozcji do tabeli | package com.model.day1.game;
import java.util.Scanner;
public class Waz {
private int wielkosc;
private char[][] mapa;
private Gracz gracz;
private int[][] tabPoz;
// konstruktor
public Waz(int wielkosc, Gracz gracz) {
this.wielkosc = wielkosc;
this.mapa = new char[wielkosc][wielkosc];
this.gracz = gracz;
}
public void emptyMap() {
for (int i = 0; i < mapa.length; i++) {
for (int j = 0; j < mapa.length; j++) {
if (((i == 0) || i == (mapa.length - 1) || (j == 0) || (j == (mapa.length - 1)))) {
mapa[i][j] = '&';
} else {
mapa[i][j] = '.';
}
}
}
}
public void fillMap() {
for (int i = 0; i < mapa.length; i++) {
for (int j = 0; j < mapa.length; j++) {
if (((i == 0) || i == (mapa.length - 1) || (j == 0) || (j == (mapa.length - 1)))) {
mapa[i][j] = '&';
} else {
mapa[i][j] = '.';
}
}
}
// tutaj można dodawać pozycje!
// mapa[1][1]='q';
// mapa[2][2]='q';
// mapa[3][3]='q';
ustawPozPionka();
}
public void printMap() {
for (int i = 0; i < mapa.length; i++) {
for (int j = 0; j < mapa.length; j++) {
System.out.print(mapa[i][j]);
}
System.out.println();
}
}
public void ustawPozPionka() {
mapa[gracz.getX()][gracz.getY()] = gracz.getSymbol();
}
public void ruchy() throws InterruptedException {
Scanner input = new Scanner(System.in);
// licznik ruchów
int licznikRuchow = 1;
int[][] tabPoz = new int[100][10];
// pytanie użytkownika o ruch
System.out.println("Ruch: \ngóra w\ndół s\nLewo a\nPrawo d\nWyjście x");
String wybor = "";
boolean flaga = false;
do {
wybor = input.nextLine();
switch (wybor) {
case "w":
try {
gracz.setX(gracz.getX() - 1);
for (int i = 2; i <= licznikRuchow; i++) {
if (
mapa[tabPoz[i][0]][tabPoz[i][1]] == mapa[(gracz.getX())][gracz.getY()]) {
System.out.println("Ugryzłeś się w zad! :P");
wybor = "x";
break;
}
}
fillMap();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Wychodzisz poza planszę \n daję Cię na środek");
gracz.setX(5);
gracz.setY(5);
}
System.out.println("zapamiętanie do tabli");
// zapamiętanie pozcji <SUF>
tabPoz[licznikRuchow][0] = (gracz.getX());
tabPoz[licznikRuchow][1] = (gracz.getY());
fillMap();
System.out.println("pionek tu był");
// to są pozycje na których pionek już był
for (int i = 0; i <= licznikRuchow; i++) {
mapa[tabPoz[i][0]][tabPoz[i][1]] = gracz.getSymbol();
}
// ustawPozPionka();
System.out.println("d!");
System.out.println("przed print");
printMap();
Thread.sleep(1000);
break;
// *************** KONIEC RUCHU "w" GÓRA ****************
case "s":
try {
gracz.setX(gracz.getX() + 1);
for (int i = 2; i <= licznikRuchow; i++) {
if (
mapa[tabPoz[i][0]][tabPoz[i][1]] == mapa[(gracz.getX())][gracz.getY()]) {
System.out.println("Ugryzłeś się w zad! :P");
wybor="x";
break;
}
break;
}
fillMap();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Wychodzisz poza planszę \n daję Cię na środek");
gracz.setX(5);
gracz.setY(5);
}
tabPoz[licznikRuchow][0] = (gracz.getX()); //tapo[0][0]=5
tabPoz[licznikRuchow][1] = (gracz.getY());
fillMap();
for (int i = 0; i <= licznikRuchow; i++) {
mapa[tabPoz[i][0]][tabPoz[i][1]] = gracz.getSymbol();
}
// ustawPozPionka();
printMap();
break;
// ******************LEWO********************
case "a":
try {
gracz.setY(gracz.getY() - 1);
for (int i = 2; i <= licznikRuchow; i++) {
if (
mapa[tabPoz[i][0]][tabPoz[i][1]] == mapa[(gracz.getX())][gracz.getY()]) {
System.out.println("Ugryzłeś się w zad! :P");
wybor="x";
break;
}
break;
}
fillMap();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Wychodzisz poza planszę \n daję Cię na środek");
gracz.setX(5);
gracz.setY(5);
}
tabPoz[licznikRuchow][0] = (gracz.getX()); //tapo[0][0]=5
tabPoz[licznikRuchow][1] = (gracz.getY());
fillMap();
for (int i = 0; i <= licznikRuchow; i++) {
mapa[tabPoz[i][0]][tabPoz[i][1]] = gracz.getSymbol();
}
// ustawPozPionka();
printMap();
break;
// *******************PRAWO******************************
case "d":
try {
gracz.setY(gracz.getY() + 1);
for (int i = 2; i <= licznikRuchow; i++) {
if (
mapa[tabPoz[i][0]][tabPoz[i][1]] == mapa[(gracz.getX())][gracz.getY()]) // sprawdza, czy taka pozycja już wystąpiła
{
System.out.println("Ugryzłeś się w zad! :P"); //komunikat jak weszło się na zajęte pole
wybor="x";
break;
}
}
fillMap();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Wychodzisz poza planszę \n daję Cię na środek");
gracz.setX(5);
gracz.setY(5);
}
tabPoz[licznikRuchow][0] = (gracz.getX()); //tapo[0][0]=5
tabPoz[licznikRuchow][1] = (gracz.getY());
fillMap();
for (int i = 0; i <= licznikRuchow; i++) {
mapa[tabPoz[i][0]][tabPoz[i][1]] = gracz.getSymbol();
}
// ustawPozPionka();
printMap();
break;
}
licznikRuchow++;
} while (!wybor.equalsIgnoreCase("x"));
}
public static void main(String[] args) throws InterruptedException {
Gracz gracz = new Gracz(5, 5, 'x');
Waz waz = new Waz(10, gracz);
waz.ruchy();
}
}
| t |
2849_0 | MattiusW/CV | 514 | Java/Instanceof.java | public class Instanceof
{
public class Main
{
public static void main(String[] args)
{
Osoba[] osoba = new Osoba[4];
osoba[0] = new Pracownik("Mateusz", "W", 100000);
osoba[1] = new Student("Kamil", "Kzesiu");
for (int i = 0; i < osoba.length; i++)
{
if (osoba[i] instanceof Osoba) //Sprawdza czy jest egzemplarzem klasy
osoba[i].pobierzOpis();
else
break;
}
}
}
}
abstract class Osoba
{
String imie;
String nazwisko;
Osoba(String imie, String nazwisko)
{
this.imie = imie;
this.nazwisko = nazwisko;
}
abstract void pobierzOpis();
}
class Pracownik extends Osoba
{
double wynagrodzenie;
Pracownik(String imie, String nazwisko, double wynagrodzenie)
{
super(imie, nazwisko);
this.wynagrodzenie = wynagrodzenie;
}
@Override
void pobierzOpis()
{
System.out.println("Jestem inżynierem");
System.out.println("Moję imię to: " + imie);
System.out.println("Moje zarobki to: " + wynagrodzenie);
}
}
class Student extends Osoba
{
Student(String imie, String nazwisko)
{
super(imie, nazwisko);
}
@Override
void pobierzOpis()
{
System.out.println("Jestem wiecznym studentem");
System.out.println("Nazywam się: " + imie + " " + nazwisko);
}
} | //Sprawdza czy jest egzemplarzem klasy | public class Instanceof
{
public class Main
{
public static void main(String[] args)
{
Osoba[] osoba = new Osoba[4];
osoba[0] = new Pracownik("Mateusz", "W", 100000);
osoba[1] = new Student("Kamil", "Kzesiu");
for (int i = 0; i < osoba.length; i++)
{
if (osoba[i] instanceof Osoba) //Sprawdza czy <SUF>
osoba[i].pobierzOpis();
else
break;
}
}
}
}
abstract class Osoba
{
String imie;
String nazwisko;
Osoba(String imie, String nazwisko)
{
this.imie = imie;
this.nazwisko = nazwisko;
}
abstract void pobierzOpis();
}
class Pracownik extends Osoba
{
double wynagrodzenie;
Pracownik(String imie, String nazwisko, double wynagrodzenie)
{
super(imie, nazwisko);
this.wynagrodzenie = wynagrodzenie;
}
@Override
void pobierzOpis()
{
System.out.println("Jestem inżynierem");
System.out.println("Moję imię to: " + imie);
System.out.println("Moje zarobki to: " + wynagrodzenie);
}
}
class Student extends Osoba
{
Student(String imie, String nazwisko)
{
super(imie, nazwisko);
}
@Override
void pobierzOpis()
{
System.out.println("Jestem wiecznym studentem");
System.out.println("Nazywam się: " + imie + " " + nazwisko);
}
} | t |
7133_4 | Mefjuu94/Projekty | 633 | Transfer/Sender/src/FileTransfer.java | import javax.swing.*;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
public class FileTransfer {
Panel panel;
String sciezkaPliku = "C:\\Users\\mateu\\Downloads\\Cassius - I Love You So (Original Mix) [HQ]";
String adresOdbiorcy = "192.168.0.107"; //"192.168.0.106"; mój komp
String nameOfFile = "";
int port = 12345;
FileTransfer(){
}
public void send(String sciezkaPliku, String name, String adresOdbiorcy) {
//this.sciezkaPliku = sciezkaPliku;
try {
// Odczyt pliku z nadawcy
Path sciezka = Paths.get(sciezkaPliku);
byte[] danePliku = Files.readAllBytes(sciezka);
byte[] nazwa = name.getBytes();
System.out.println(Arrays.toString(nazwa));
int ileDanych = nazwa.length;
System.out.println(name);
// Ustanowienie połączenia z odbiorcą
try (Socket socket = new Socket(adresOdbiorcy, port)) {
// Uzyskanie strumienia wejściowego i wyjściowego
OutputStream out = socket.getOutputStream();
InputStream in = socket.getInputStream();
// Wysyłanie rozmiaru pliku
System.out.println(danePliku.length);
// Wysyłanie danych pliku
out.write(ileDanych);
out.write(nazwa);
System.out.println("nazwa :" + Arrays.toString(nazwa));
out.write(danePliku);
System.out.println("dane : " + Arrays.toString(danePliku));
System.out.println("Plik został pomyślnie przesłany do odbiorcy.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
} | // Uzyskanie strumienia wejściowego i wyjściowego | import javax.swing.*;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
public class FileTransfer {
Panel panel;
String sciezkaPliku = "C:\\Users\\mateu\\Downloads\\Cassius - I Love You So (Original Mix) [HQ]";
String adresOdbiorcy = "192.168.0.107"; //"192.168.0.106"; mój komp
String nameOfFile = "";
int port = 12345;
FileTransfer(){
}
public void send(String sciezkaPliku, String name, String adresOdbiorcy) {
//this.sciezkaPliku = sciezkaPliku;
try {
// Odczyt pliku z nadawcy
Path sciezka = Paths.get(sciezkaPliku);
byte[] danePliku = Files.readAllBytes(sciezka);
byte[] nazwa = name.getBytes();
System.out.println(Arrays.toString(nazwa));
int ileDanych = nazwa.length;
System.out.println(name);
// Ustanowienie połączenia z odbiorcą
try (Socket socket = new Socket(adresOdbiorcy, port)) {
// Uzyskanie strumienia <SUF>
OutputStream out = socket.getOutputStream();
InputStream in = socket.getInputStream();
// Wysyłanie rozmiaru pliku
System.out.println(danePliku.length);
// Wysyłanie danych pliku
out.write(ileDanych);
out.write(nazwa);
System.out.println("nazwa :" + Arrays.toString(nazwa));
out.write(danePliku);
System.out.println("dane : " + Arrays.toString(danePliku));
System.out.println("Plik został pomyślnie przesłany do odbiorcy.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
} | t |
9051_10 | Michael-Pytel/Weather-App | 3,281 | WeatherApp/src/main/java/pl/edu/pw/mini/zpoif/pytelrogalska/weatherapp/service/WeatherService.java | package pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.config.Config;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.model.List;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.model.Main;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.model.MainObject;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.pollution.MainPollutionObject;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.pollution.PollutionList;
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
@Service
public class WeatherService {
private final Config config;
protected final WeatherApiClient weatherApiClient;
static final String API_KEY = "13662892eb587f841013ffacb523c53e";
private final DataMapper dataMapper;
private static final Logger SERVICE_LOGGER = LoggerFactory.getLogger(WeatherService.class);
@Autowired
public WeatherService(Config config, WeatherApiClient weatherApiClient, DataMapper dataMapper) {
this.config = config;
this.weatherApiClient = weatherApiClient;
this.dataMapper = dataMapper;
}
@PostConstruct //najpierw wywołana metoda tylko generateMainWeatherClasses,
// żeby potem móc działać na klasach i obiektach, potem generowanie PollutionClasses
public void init() throws IOException {
/* String cityName = "Warsaw";
config.generateMainWeatherClasses(cityName,apikey);
MainObject objectExample = generateObjectFromJson("Warsaw","metric");
Double lat = objectExample.getCity().getCoord().getLat();
Double lng = objectExample.getCity().getCoord().getLon();
config.generatePollutionClasses(lat,lng,apikey);*/
}
// metoda generuje informacje pogodowe oraz o zanieczyszczeniu powietrza dla danego miasta w wybranym zakresie czasowym
public String getObjectWeatherInfo(String cityName, String units, LocalDateTime startDate, LocalDateTime endDate) throws IOException {
MainObject weatherObject = dataMapper.generateObjectFromJson(cityName,units); //obiekt z WeatherApi
SERVICE_LOGGER.info("Main Weather Object created with city: "+ cityName);
String lat = String.valueOf(weatherObject.getCity().getCoord().getLat()); //pobranie wspólrzędnych podanego miasta
String lng = String.valueOf(weatherObject.getCity().getCoord().getLon());
MainPollutionObject pollutionObject = dataMapper.generatePollutionFromJSON(lat,lng);// obiekt z PollutionApi dla wybranego miasta
SERVICE_LOGGER.info("Main Pollution Object created with lattitude:"+ lat);
//pobranie list z elementami z obu obiektów
java.util.List<List> lista = weatherObject.getList();
java.util.List<PollutionList> listaPollution = pollutionObject.getList();
StringBuilder infoPogodowe = new StringBuilder();
// sprawdzenie czy podane jednostki są prawidłowe, jeśli nie to API default i informacja na ekranie
if(!(units.equals("metric") || units.equals("standard") || units.equals("imperial"))){
SERVICE_LOGGER.info("Incorrect units. Weather shown in default units");
infoPogodowe.append("<i>"+"Uwaga : Podane jednostki temperatury są w nieprawidłowym formacie. Domyślne jednostki to: Kelvin, m/s."+"<br>"+ "Aby zobaczyć temperaturę w Celsjuszach użyj : metric, w Farenheitach użyj : imperial."+"<br>"+"<br>"+"</i>");
}
// jeśli prawidłowe to ustawiamy
String jednostkaT;
jednostkaT = switch (units) {
case "metric" -> " °C ";
case "imperial" -> " °F ";
default -> " K ";
};
String jednostkaV;
jednostkaV = switch (units){
case "imperial" -> "miles/h";
default -> "m/s";
};
boolean czySaDane=false; //flaga czy znajdziemy dane w wybranym zakresie czasowym
infoPogodowe.append("<i>"+"Informacje pogodowe w wybranym zakresie czasowym:"+"<br>"+"<br>"+"</i>");
java.util.List<LocalDateTime> listaDat = new ArrayList<>(); //tworzymy liste na daty, które wystąpią w WeatherAPI
for(List list: lista){
// zamiana pobranej daty na format LocalDateTime
Integer wDate = list.getDt();
Date wDateFixed = new Date(wDate *1000L);
LocalDateTime wlocalDate = wDateFixed.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
//jeśli data w podanym przedziale to pobieramy pogodę
if(wlocalDate.isAfter(startDate) && wlocalDate.isBefore(endDate)){
czySaDane=true; //zmiana flagi
listaDat.add(wlocalDate); // dodanie daty do listy dat i pobranie informacji
String data = ""+wlocalDate;
infoPogodowe.append("<b>" + "POGODA W DNIU: ").append(data, 0, 10).append(" O GODZINIE: ").append(data, 11, 16).append("</b>");
infoPogodowe.append("<br>");
Main main = list.getMain();
infoPogodowe.append("<b>" + "<i>" + " Temperatura: " + "</b>" + "</i>" + "<br>" + " Rzeczywista: ").append(main.getTemp()).append(" ").append(jednostkaT).append("<br>");
infoPogodowe.append("<i>" + " Odczuwalna: " + "</i>").append(main.getFeelsLike()).append(" ").append(jednostkaT).append("<br>");
infoPogodowe.append("<b>" + " Zachmurzenie : " + "<br>" + "</b>").append(list.getClouds().getAll()).append("%").append("<br>");
infoPogodowe.append("<b>" + " Widoczność: " + "<br>" + "</b>").append(list.getVisibility()).append("m").append("<br>");
infoPogodowe.append("<b>" + " Wiatr : " + "<br>" + "</b>" + "<i>" + " Prędkość: " + "</i>").append(list.getWind().getSpeed()).append(" ").append(jednostkaV);
infoPogodowe.append("<br>" + "<i>" + "Kierunek: " + "</i>").append(list.getWind().getDeg()).append("<br>").append("<i>").append(" Porywy: ").append("</i>").append(list.getWind().getGust()).append(" ").append(jednostkaV);
infoPogodowe.append("<br>" + "<b>" + "Wilgotność: " + "</b>" + "<br>").append(list.getMain().getHumidity()).append("%");
// przejscie do danych z PollutionAPI
infoPogodowe.append("<b>"+"<br>"+"Jakość powietrza"+"</b>"+"<br>");
for(PollutionList pl : listaPollution){
// zamiana daty na LocalDateTime
Integer pDate= pl.getDt();
Date pDateFixed = new Date(pDate *1000L);
LocalDateTime pDateLocal = pDateFixed.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
// sprawdzamy, czy data jest zgodna z jakąś z dat dla informacji pogodowych i pobranie danych
if(listaDat.contains(pDateLocal)){
infoPogodowe.append("<i>" + "Index jakości : " + "</i>").append(+pl.getMain().getAqi());
Integer index = pl.getMain().getAqi();
switch (index){ // wyjaśnienie znaczenia indeksów aqi
case 1:
infoPogodowe.append(" (jakość dobra)");
break;
case 2:
infoPogodowe.append(" (jakość w porządku)");
break;
case 3:
infoPogodowe.append(" (jakość średnia)");
break;
case 4:
infoPogodowe.append(" (jakość słaba)");
break;
case 5:
infoPogodowe.append(" (jakość bardzo słaba)");
}
infoPogodowe.append("<br>" + "<i>" + "Stężenie tlenku węgla (CO) : " + "</i>").append(pl.getComponents().getCo()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie tlenku azotu (NO): " + "</i>").append(pl.getComponents().getNo()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie dwutlenku azotu (NO²): " + "</i>").append(pl.getComponents().getNo2()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie ozonu (O³): " + "</i>").append(pl.getComponents().getO3()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie dwutlenku siarki (SO²): " + "</i>").append(pl.getComponents().getSo2()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie pyłków zawieszonych: " + "</i>").append(pl.getComponents().getPm25()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie amoniaku (NH³): " + "</i>").append(pl.getComponents().getNh3()).append(" µg/m³");
// usunięcie danej daty z listy dat. Jeśli nie usuniemy to w każdej kolejnej informacji będą też dane z poprzedniej daty
Iterator<LocalDateTime> iterator = listaDat.iterator();
while (iterator.hasNext()) {
LocalDateTime current = iterator.next();
if (current.equals(pDateLocal)) {
iterator.remove();
}
}
}
}
infoPogodowe.append( "<br>"+"<br>");
}}
// sprawdzamy flagę czy znaleziono dane dla danego przedziału, jeśli nie to komunikat, jeśli tak to informacje pogodowe
if(!czySaDane){
SERVICE_LOGGER.info("No weather data between given dates");
return "<b>"+"SELECTED CITY : " + cityName+"</b>" + "<br>"+ "Niestety nie mamy danych dla podanego zakresu czasowego. Proszę spróbować podać inny zakres";
}
else{
SERVICE_LOGGER.info("Weather data shown");
}
return "<b>"+"SELECTED CITY : " + cityName+"</b>" + "<br>"+ "<br>" +infoPogodowe + "<br>"+"<br>"+ "Informacje specjalistyczne:"+"<br>" ;
}
}
| //flaga czy znajdziemy dane w wybranym zakresie czasowym | package pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.config.Config;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.model.List;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.model.Main;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.model.MainObject;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.pollution.MainPollutionObject;
import pl.edu.pw.mini.zpoif.pytelrogalska.weatherapp.pollution.PollutionList;
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
@Service
public class WeatherService {
private final Config config;
protected final WeatherApiClient weatherApiClient;
static final String API_KEY = "13662892eb587f841013ffacb523c53e";
private final DataMapper dataMapper;
private static final Logger SERVICE_LOGGER = LoggerFactory.getLogger(WeatherService.class);
@Autowired
public WeatherService(Config config, WeatherApiClient weatherApiClient, DataMapper dataMapper) {
this.config = config;
this.weatherApiClient = weatherApiClient;
this.dataMapper = dataMapper;
}
@PostConstruct //najpierw wywołana metoda tylko generateMainWeatherClasses,
// żeby potem móc działać na klasach i obiektach, potem generowanie PollutionClasses
public void init() throws IOException {
/* String cityName = "Warsaw";
config.generateMainWeatherClasses(cityName,apikey);
MainObject objectExample = generateObjectFromJson("Warsaw","metric");
Double lat = objectExample.getCity().getCoord().getLat();
Double lng = objectExample.getCity().getCoord().getLon();
config.generatePollutionClasses(lat,lng,apikey);*/
}
// metoda generuje informacje pogodowe oraz o zanieczyszczeniu powietrza dla danego miasta w wybranym zakresie czasowym
public String getObjectWeatherInfo(String cityName, String units, LocalDateTime startDate, LocalDateTime endDate) throws IOException {
MainObject weatherObject = dataMapper.generateObjectFromJson(cityName,units); //obiekt z WeatherApi
SERVICE_LOGGER.info("Main Weather Object created with city: "+ cityName);
String lat = String.valueOf(weatherObject.getCity().getCoord().getLat()); //pobranie wspólrzędnych podanego miasta
String lng = String.valueOf(weatherObject.getCity().getCoord().getLon());
MainPollutionObject pollutionObject = dataMapper.generatePollutionFromJSON(lat,lng);// obiekt z PollutionApi dla wybranego miasta
SERVICE_LOGGER.info("Main Pollution Object created with lattitude:"+ lat);
//pobranie list z elementami z obu obiektów
java.util.List<List> lista = weatherObject.getList();
java.util.List<PollutionList> listaPollution = pollutionObject.getList();
StringBuilder infoPogodowe = new StringBuilder();
// sprawdzenie czy podane jednostki są prawidłowe, jeśli nie to API default i informacja na ekranie
if(!(units.equals("metric") || units.equals("standard") || units.equals("imperial"))){
SERVICE_LOGGER.info("Incorrect units. Weather shown in default units");
infoPogodowe.append("<i>"+"Uwaga : Podane jednostki temperatury są w nieprawidłowym formacie. Domyślne jednostki to: Kelvin, m/s."+"<br>"+ "Aby zobaczyć temperaturę w Celsjuszach użyj : metric, w Farenheitach użyj : imperial."+"<br>"+"<br>"+"</i>");
}
// jeśli prawidłowe to ustawiamy
String jednostkaT;
jednostkaT = switch (units) {
case "metric" -> " °C ";
case "imperial" -> " °F ";
default -> " K ";
};
String jednostkaV;
jednostkaV = switch (units){
case "imperial" -> "miles/h";
default -> "m/s";
};
boolean czySaDane=false; //flaga czy <SUF>
infoPogodowe.append("<i>"+"Informacje pogodowe w wybranym zakresie czasowym:"+"<br>"+"<br>"+"</i>");
java.util.List<LocalDateTime> listaDat = new ArrayList<>(); //tworzymy liste na daty, które wystąpią w WeatherAPI
for(List list: lista){
// zamiana pobranej daty na format LocalDateTime
Integer wDate = list.getDt();
Date wDateFixed = new Date(wDate *1000L);
LocalDateTime wlocalDate = wDateFixed.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
//jeśli data w podanym przedziale to pobieramy pogodę
if(wlocalDate.isAfter(startDate) && wlocalDate.isBefore(endDate)){
czySaDane=true; //zmiana flagi
listaDat.add(wlocalDate); // dodanie daty do listy dat i pobranie informacji
String data = ""+wlocalDate;
infoPogodowe.append("<b>" + "POGODA W DNIU: ").append(data, 0, 10).append(" O GODZINIE: ").append(data, 11, 16).append("</b>");
infoPogodowe.append("<br>");
Main main = list.getMain();
infoPogodowe.append("<b>" + "<i>" + " Temperatura: " + "</b>" + "</i>" + "<br>" + " Rzeczywista: ").append(main.getTemp()).append(" ").append(jednostkaT).append("<br>");
infoPogodowe.append("<i>" + " Odczuwalna: " + "</i>").append(main.getFeelsLike()).append(" ").append(jednostkaT).append("<br>");
infoPogodowe.append("<b>" + " Zachmurzenie : " + "<br>" + "</b>").append(list.getClouds().getAll()).append("%").append("<br>");
infoPogodowe.append("<b>" + " Widoczność: " + "<br>" + "</b>").append(list.getVisibility()).append("m").append("<br>");
infoPogodowe.append("<b>" + " Wiatr : " + "<br>" + "</b>" + "<i>" + " Prędkość: " + "</i>").append(list.getWind().getSpeed()).append(" ").append(jednostkaV);
infoPogodowe.append("<br>" + "<i>" + "Kierunek: " + "</i>").append(list.getWind().getDeg()).append("<br>").append("<i>").append(" Porywy: ").append("</i>").append(list.getWind().getGust()).append(" ").append(jednostkaV);
infoPogodowe.append("<br>" + "<b>" + "Wilgotność: " + "</b>" + "<br>").append(list.getMain().getHumidity()).append("%");
// przejscie do danych z PollutionAPI
infoPogodowe.append("<b>"+"<br>"+"Jakość powietrza"+"</b>"+"<br>");
for(PollutionList pl : listaPollution){
// zamiana daty na LocalDateTime
Integer pDate= pl.getDt();
Date pDateFixed = new Date(pDate *1000L);
LocalDateTime pDateLocal = pDateFixed.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
// sprawdzamy, czy data jest zgodna z jakąś z dat dla informacji pogodowych i pobranie danych
if(listaDat.contains(pDateLocal)){
infoPogodowe.append("<i>" + "Index jakości : " + "</i>").append(+pl.getMain().getAqi());
Integer index = pl.getMain().getAqi();
switch (index){ // wyjaśnienie znaczenia indeksów aqi
case 1:
infoPogodowe.append(" (jakość dobra)");
break;
case 2:
infoPogodowe.append(" (jakość w porządku)");
break;
case 3:
infoPogodowe.append(" (jakość średnia)");
break;
case 4:
infoPogodowe.append(" (jakość słaba)");
break;
case 5:
infoPogodowe.append(" (jakość bardzo słaba)");
}
infoPogodowe.append("<br>" + "<i>" + "Stężenie tlenku węgla (CO) : " + "</i>").append(pl.getComponents().getCo()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie tlenku azotu (NO): " + "</i>").append(pl.getComponents().getNo()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie dwutlenku azotu (NO²): " + "</i>").append(pl.getComponents().getNo2()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie ozonu (O³): " + "</i>").append(pl.getComponents().getO3()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie dwutlenku siarki (SO²): " + "</i>").append(pl.getComponents().getSo2()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie pyłków zawieszonych: " + "</i>").append(pl.getComponents().getPm25()).append(" µg/m³");
infoPogodowe.append("<br>" + "<i>" + "Stężenie amoniaku (NH³): " + "</i>").append(pl.getComponents().getNh3()).append(" µg/m³");
// usunięcie danej daty z listy dat. Jeśli nie usuniemy to w każdej kolejnej informacji będą też dane z poprzedniej daty
Iterator<LocalDateTime> iterator = listaDat.iterator();
while (iterator.hasNext()) {
LocalDateTime current = iterator.next();
if (current.equals(pDateLocal)) {
iterator.remove();
}
}
}
}
infoPogodowe.append( "<br>"+"<br>");
}}
// sprawdzamy flagę czy znaleziono dane dla danego przedziału, jeśli nie to komunikat, jeśli tak to informacje pogodowe
if(!czySaDane){
SERVICE_LOGGER.info("No weather data between given dates");
return "<b>"+"SELECTED CITY : " + cityName+"</b>" + "<br>"+ "Niestety nie mamy danych dla podanego zakresu czasowego. Proszę spróbować podać inny zakres";
}
else{
SERVICE_LOGGER.info("Weather data shown");
}
return "<b>"+"SELECTED CITY : " + cityName+"</b>" + "<br>"+ "<br>" +infoPogodowe + "<br>"+"<br>"+ "Informacje specjalistyczne:"+"<br>" ;
}
}
| t |
9387_3 | MichalKapala/PRIR | 911 | zadanie3/Zadanie3/src/Cinema.java | import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.Set;
public interface Cinema extends Remote {
public static String SERVICE_NAME = "CINEMA";
/**
* Metoda konfigurująca parametry systemu.
*
* @param seats liczba miejsc
* @param timeForConfirmation czas w milisekundach na potwierdzenie rezerwacji
* @throws RemoteException wyjątek wymagany przez RMI
*/
public void configuration(int seats, long timeForConfirmation) throws RemoteException;
/**
* Miejsca, które można zarezerwować. Zbiór nie zawiera miejsc, których
* rezerwacja została już potwierdzona i tych, których czas oczekiwania na
* potwierdzenie rezerwacji jeszcze nie minął.
*
* @return zbiór numerów niezarezerwowanych miejsc
* @throws RemoteException wyjątek wymagany przez RMI
*/
public Set<Integer> notReservedSeats() throws RemoteException;
/**
* Zgłoszenie rezerwacji przez użytkownika o podanej nazwie.
*
* @param user nazwa użytkownika serwisu
* @param seats zbiór miejsc, które użytkownik serwisu chce zarejestrować.
* @return true - miejsca o podanych numerach mogą zostać zarezerwowane. false -
* rezerwacja nie może być zrealizowana, bo nie wszystkie wymienione
* miesca są dostępne
* @throws RemoteException wyjątek wymagany przez RMI
*/
public boolean reservation(String user, Set<Integer> seats) throws RemoteException;
/**
* Po uzyskaniu potwierdzenia, że miejsca mogą być zarezerwowane użytkownik musi
* rezerwację jeszcze potwierdzić. Rezerwacja wykonana w czasie
* timeForConfirmation od uzyskania informacji o dostępności musi zostać przez
* system zaakceptowana i zarezerwowane miejsca nie mogą być przez ten czas
* nikomu oferowane. Jeśli potwierdzenie pojawi się później, nie ma gwaracji, że
* miejsca są jeszcze dostępne.
*
* @param user nazwa użytkownika serwisu
* @return true - rezerwacja miesc potwierdzona, false - miejsca nie są już
* dostępne (tylko w przypadku spoźnionego potwierdzenia i rezerwacji
* (nawet niepotwierdzonej) miejsca przez kogoś innego)
* @throws RemoteException wyjątek wymagany przez RMI
*/
public boolean confirmation(String user) throws RemoteException;
/**
* Informacja o użytkowniku, który dokonał potwierdzonej rezerwacji miejsca. Do
* chwili zaakceptowania potwierdzenia metoda zwraca null.
*
* @param seat numer miejsca
* @return nazwa użytkownika, który z sukcesem przeprowadził proces rejestracji
* @throws RemoteException wyjątek wymagany przez RMI
*/
public String whoHasReservation(int seat) throws RemoteException;
}
| /**
* Po uzyskaniu potwierdzenia, że miejsca mogą być zarezerwowane użytkownik musi
* rezerwację jeszcze potwierdzić. Rezerwacja wykonana w czasie
* timeForConfirmation od uzyskania informacji o dostępności musi zostać przez
* system zaakceptowana i zarezerwowane miejsca nie mogą być przez ten czas
* nikomu oferowane. Jeśli potwierdzenie pojawi się później, nie ma gwaracji, że
* miejsca są jeszcze dostępne.
*
* @param user nazwa użytkownika serwisu
* @return true - rezerwacja miesc potwierdzona, false - miejsca nie są już
* dostępne (tylko w przypadku spoźnionego potwierdzenia i rezerwacji
* (nawet niepotwierdzonej) miejsca przez kogoś innego)
* @throws RemoteException wyjątek wymagany przez RMI
*/ | import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.Set;
public interface Cinema extends Remote {
public static String SERVICE_NAME = "CINEMA";
/**
* Metoda konfigurująca parametry systemu.
*
* @param seats liczba miejsc
* @param timeForConfirmation czas w milisekundach na potwierdzenie rezerwacji
* @throws RemoteException wyjątek wymagany przez RMI
*/
public void configuration(int seats, long timeForConfirmation) throws RemoteException;
/**
* Miejsca, które można zarezerwować. Zbiór nie zawiera miejsc, których
* rezerwacja została już potwierdzona i tych, których czas oczekiwania na
* potwierdzenie rezerwacji jeszcze nie minął.
*
* @return zbiór numerów niezarezerwowanych miejsc
* @throws RemoteException wyjątek wymagany przez RMI
*/
public Set<Integer> notReservedSeats() throws RemoteException;
/**
* Zgłoszenie rezerwacji przez użytkownika o podanej nazwie.
*
* @param user nazwa użytkownika serwisu
* @param seats zbiór miejsc, które użytkownik serwisu chce zarejestrować.
* @return true - miejsca o podanych numerach mogą zostać zarezerwowane. false -
* rezerwacja nie może być zrealizowana, bo nie wszystkie wymienione
* miesca są dostępne
* @throws RemoteException wyjątek wymagany przez RMI
*/
public boolean reservation(String user, Set<Integer> seats) throws RemoteException;
/**
* Po uzyskaniu potwierdzenia, <SUF>*/
public boolean confirmation(String user) throws RemoteException;
/**
* Informacja o użytkowniku, który dokonał potwierdzonej rezerwacji miejsca. Do
* chwili zaakceptowania potwierdzenia metoda zwraca null.
*
* @param seat numer miejsca
* @return nazwa użytkownika, który z sukcesem przeprowadził proces rejestracji
* @throws RemoteException wyjątek wymagany przez RMI
*/
public String whoHasReservation(int seat) throws RemoteException;
}
| t |
3708_0 | MichalKozlowskii/java-introduction-course | 483 | Lista2/zad1.java | import java.util.Arrays;
public class Main {
public static int missingNumber(int[] arr) {
Arrays.sort(arr); // sortujemy otrzymany array od najmniejszej
int N = arr.length;
int max = arr[N-1];
int lastNum = arr[0];
int index = 0;
int solution = 0;
int gapCount = 0;
for (int num : arr) {
if (num < 0) {
System.out.println("Wszystkie elementy tablicy muszą być liczbami naturalnymi!");
return 0;
}
if (index > 0 && num == lastNum) {
System.out.println("Wszystkie elementy tablicy muszą być unikalne!");
return 0;
}
if (num - lastNum > 2) {
System.out.println("W tablicy brakuje więcej niż jednego elementu!");
return 0;
}
if (num - lastNum == 2) {
solution = num - 1;
gapCount++;
}
if (num == arr[N-1] && num < N) { // jeśli nie znaleźliśmy jeszcze braku, a to ostatni element.
if (gapCount >= 1) {
System.out.println("W tablicy brakuje więcej niż jednego elementu!");
return 0;
}
solution = num + 1;
}
lastNum = num;
index++;
}
return solution;
}
public static void main(String[] args) {
int[] tab = new int[]{2, 4, 5, 3, 0, 6}; // N = 6
System.out.println(missingNumber(tab));
}
} | // sortujemy otrzymany array od najmniejszej | import java.util.Arrays;
public class Main {
public static int missingNumber(int[] arr) {
Arrays.sort(arr); // sortujemy otrzymany <SUF>
int N = arr.length;
int max = arr[N-1];
int lastNum = arr[0];
int index = 0;
int solution = 0;
int gapCount = 0;
for (int num : arr) {
if (num < 0) {
System.out.println("Wszystkie elementy tablicy muszą być liczbami naturalnymi!");
return 0;
}
if (index > 0 && num == lastNum) {
System.out.println("Wszystkie elementy tablicy muszą być unikalne!");
return 0;
}
if (num - lastNum > 2) {
System.out.println("W tablicy brakuje więcej niż jednego elementu!");
return 0;
}
if (num - lastNum == 2) {
solution = num - 1;
gapCount++;
}
if (num == arr[N-1] && num < N) { // jeśli nie znaleźliśmy jeszcze braku, a to ostatni element.
if (gapCount >= 1) {
System.out.println("W tablicy brakuje więcej niż jednego elementu!");
return 0;
}
solution = num + 1;
}
lastNum = num;
index++;
}
return solution;
}
public static void main(String[] args) {
int[] tab = new int[]{2, 4, 5, 3, 0, 6}; // N = 6
System.out.println(missingNumber(tab));
}
} | t |
6768_2 | MichjuX/KontrolaLotow | 610 | src/AirShip.java | public class AirShip {//
protected Route flight;// trasa lotu
protected Rectangle hitBox;
protected Point currentLocation;
protected double velocity;
protected double height; // i prosokat tez musi miec te sama wysokosc
private int currentLineIndex = 0;
public AirShip(Point startingLocation, double width, double height)
{
this.currentLocation=startingLocation;
hitBox = new Rectangle(startingLocation, width, height);
}
public void move(double dx, double dy) //tu jaoks trzeba zrobic zeby np airship dziedziczyl punkt z rectangle albo odwrotnie
{
currentLocation.move(dx,dy);
hitBox.move(dx, dy);
}
// Przesuwa AirShip wzdłuż jego trasy
public void moveAlongRoute() {
Line currentLine = flight.getLine(currentLineIndex);
Point direction = currentLine.direction();
// Przesunięcie AirShip o jednostkową odległość w kierunku linii
move(direction.getX(), direction.getY());
// Jeżeli AirShip doszedł do końca bieżącej linii
if (currentLocation.getX() >= currentLine.getEnding().getX() &&
currentLocation.getY() >= currentLine.getEnding().getY()) {
// Przejście do następnej linii
currentLineIndex++;
// Jeżeli AirShip doszedł do końca trasy
if (currentLineIndex >= flight.getLinesNumber()) {
// Powrót do początku trasy
currentLineIndex = 0;
}
}
}
public void setFlight(Route route)
{
this.flight = route;
}
public void setVelocity(double velocity)
{
this.velocity = velocity;
}
public void setHeight(double height)
{
this.height = height;
hitBox.setHeight(height);
}
public void setHeight()
{
this.height = 100;
hitBox.setHeight(100);
}
public void setVelocity()
{
this.velocity = 20;
}
public Point getCurrentLocation() {
return currentLocation;
}
}
| // Przesuwa AirShip wzdłuż jego trasy | public class AirShip {//
protected Route flight;// trasa lotu
protected Rectangle hitBox;
protected Point currentLocation;
protected double velocity;
protected double height; // i prosokat tez musi miec te sama wysokosc
private int currentLineIndex = 0;
public AirShip(Point startingLocation, double width, double height)
{
this.currentLocation=startingLocation;
hitBox = new Rectangle(startingLocation, width, height);
}
public void move(double dx, double dy) //tu jaoks trzeba zrobic zeby np airship dziedziczyl punkt z rectangle albo odwrotnie
{
currentLocation.move(dx,dy);
hitBox.move(dx, dy);
}
// Przesuwa AirShip <SUF>
public void moveAlongRoute() {
Line currentLine = flight.getLine(currentLineIndex);
Point direction = currentLine.direction();
// Przesunięcie AirShip o jednostkową odległość w kierunku linii
move(direction.getX(), direction.getY());
// Jeżeli AirShip doszedł do końca bieżącej linii
if (currentLocation.getX() >= currentLine.getEnding().getX() &&
currentLocation.getY() >= currentLine.getEnding().getY()) {
// Przejście do następnej linii
currentLineIndex++;
// Jeżeli AirShip doszedł do końca trasy
if (currentLineIndex >= flight.getLinesNumber()) {
// Powrót do początku trasy
currentLineIndex = 0;
}
}
}
public void setFlight(Route route)
{
this.flight = route;
}
public void setVelocity(double velocity)
{
this.velocity = velocity;
}
public void setHeight(double height)
{
this.height = height;
hitBox.setHeight(height);
}
public void setHeight()
{
this.height = 100;
hitBox.setHeight(100);
}
public void setVelocity()
{
this.velocity = 20;
}
public Point getCurrentLocation() {
return currentLocation;
}
}
| t |
6334_14 | MikolajDuda/Synthesizer | 1,384 | Prezentacja/src/Prezentacja.java | import javax.sound.midi.*;
public class Prezentacja {
public static void main(String[] args) {
// DŹWIĘK //
try {
Synthesizer synthesizer = MidiSystem.getSynthesizer();
/*
Pobieramy gotowy syntezator z zaimportowanego interfejsu MIDI
Należy również obsłużyc wyjątek- dlatego kod zostaje opakowany w blok try-catch
*/
synthesizer.open();
//Aby można było operować na sytezatorze należy wykonać metodę open()
MidiChannel channel = synthesizer.getChannels()[0]; //Będziemy korzystać tylko z 1-wszego kanału
//lista wszystkich dostępnych instrumentów, poza bankiem podstawowym jest ona poszerzona o inne banki
Instrument[] instruments = synthesizer.getAvailableInstruments();
System.out.println("Pierwszy dźwięk");
channel.noteOn(80, 80); //Ton C4, głośność 100 wg MIDI (zakres: <0, 127>)
Thread.sleep(2000); //Uśpienie wątku jest potrzebne, aby usłyszeć wydobyty dźwięk przed zakończeniem programu.
// INSTRUMENTY //
/*
MIDI oferuje nam szereg instrumentów.
Ich pełną listę znajdziecie pod linkiem: https://www.midi.org/specifications-old/item/gm-level-1-sound-set
Na 20 pozycji znajdują się organy. Czy ta komenda zmieni aktualny instrument?
Nie. Służy ona do udostępnienia/załadowania instrumentu syntezatorowi, jednak nie mówi 'tak masz grać'
*/
synthesizer.loadInstrument(instruments[20]);
System.out.println("loadInstrument(Church Organ)");
channel.noteOn(80, 80);
Thread.sleep(2000);
/*
Aby wybrać instrument należy posłużyć się poleceniem programChange(bank, instrument)
W tym programie korzystamy z banku podstawowego więc wartość 'bank' = 0
*/
channel.programChange(0, 20);
System.out.println("programChange(Church Organ)");
channel.noteOn(80, 80);
Thread.sleep(2000);
//Bardzo ważne. Zagrane dźwięki będą trwać w nieskończoność, jeżeli ich nie wyłączymy
channel.noteOff(80);
//Wróćmy do pianina
channel.programChange(0, 0);
// EFEKTY //
/*
Aby nałożyć efekt na dźwięk należy posłużyć się kontrolerami.
Lista kontrolerów: https://www.midi.org/specifications-old/item/table-3-control-change-messages-data-bytes-2
controlChange() wysyła informację o zmianie stanu kontrolera.
Nie musimy się martwić aktualizacją stanu syntezatora i kanałów.
*/
channel.controlChange(77, 120); //Kontroler głębokości Vibrato
System.out.println("Vibrato");
channel.noteOn(80, 80);
Thread.sleep(2000);
} catch (MidiUnavailableException | InterruptedException e) {
e.printStackTrace();
}
}
}
/*
Bibliografia:
opis syntezatora:
https://pl.wikipedia.org/wiki/Syntezator
https://en.wikipedia.org/wiki/Synthesizer
zdjęcia syntezatorów:
https://www.nordkeyboards.com/
https://pl.wikipedia.org/wiki/Syntezator
https://musiccenter.pl/
Opis dźwięku:
https://pl.wikipedia.org/wiki/Dźwięk
opisy fal:
http://users.cs.cf.ac.uk/Dave.Marshall/CM0268/PDF/07_CM0268_DSP.pdf
https://en.wikipedia.org/wiki/Triangle_wave
https://en.wikipedia.org/wiki/Sawtooth_wave
https://www.youtube.com/watch?v=OSCzKOqtgcA&t=1284s
Opisy SoundMaker:
https://docs.oracle.com/javase/tutorial/sound/sampled-overview.html
opisy efektów:
http://users.cs.cf.ac.uk/Dave.Marshall/CM0268/PDF/10_CM0268_Audio_FX.pdf
MIDI:
https://docs.oracle.com/javase/tutorial/sound/sampled-overview.html
https://www.ibm.com/developerworks/library/it/it-0801art38/
https://www.midi.org/
*/
| //Kontroler głębokości Vibrato | import javax.sound.midi.*;
public class Prezentacja {
public static void main(String[] args) {
// DŹWIĘK //
try {
Synthesizer synthesizer = MidiSystem.getSynthesizer();
/*
Pobieramy gotowy syntezator z zaimportowanego interfejsu MIDI
Należy również obsłużyc wyjątek- dlatego kod zostaje opakowany w blok try-catch
*/
synthesizer.open();
//Aby można było operować na sytezatorze należy wykonać metodę open()
MidiChannel channel = synthesizer.getChannels()[0]; //Będziemy korzystać tylko z 1-wszego kanału
//lista wszystkich dostępnych instrumentów, poza bankiem podstawowym jest ona poszerzona o inne banki
Instrument[] instruments = synthesizer.getAvailableInstruments();
System.out.println("Pierwszy dźwięk");
channel.noteOn(80, 80); //Ton C4, głośność 100 wg MIDI (zakres: <0, 127>)
Thread.sleep(2000); //Uśpienie wątku jest potrzebne, aby usłyszeć wydobyty dźwięk przed zakończeniem programu.
// INSTRUMENTY //
/*
MIDI oferuje nam szereg instrumentów.
Ich pełną listę znajdziecie pod linkiem: https://www.midi.org/specifications-old/item/gm-level-1-sound-set
Na 20 pozycji znajdują się organy. Czy ta komenda zmieni aktualny instrument?
Nie. Służy ona do udostępnienia/załadowania instrumentu syntezatorowi, jednak nie mówi 'tak masz grać'
*/
synthesizer.loadInstrument(instruments[20]);
System.out.println("loadInstrument(Church Organ)");
channel.noteOn(80, 80);
Thread.sleep(2000);
/*
Aby wybrać instrument należy posłużyć się poleceniem programChange(bank, instrument)
W tym programie korzystamy z banku podstawowego więc wartość 'bank' = 0
*/
channel.programChange(0, 20);
System.out.println("programChange(Church Organ)");
channel.noteOn(80, 80);
Thread.sleep(2000);
//Bardzo ważne. Zagrane dźwięki będą trwać w nieskończoność, jeżeli ich nie wyłączymy
channel.noteOff(80);
//Wróćmy do pianina
channel.programChange(0, 0);
// EFEKTY //
/*
Aby nałożyć efekt na dźwięk należy posłużyć się kontrolerami.
Lista kontrolerów: https://www.midi.org/specifications-old/item/table-3-control-change-messages-data-bytes-2
controlChange() wysyła informację o zmianie stanu kontrolera.
Nie musimy się martwić aktualizacją stanu syntezatora i kanałów.
*/
channel.controlChange(77, 120); //Kontroler głębokości <SUF>
System.out.println("Vibrato");
channel.noteOn(80, 80);
Thread.sleep(2000);
} catch (MidiUnavailableException | InterruptedException e) {
e.printStackTrace();
}
}
}
/*
Bibliografia:
opis syntezatora:
https://pl.wikipedia.org/wiki/Syntezator
https://en.wikipedia.org/wiki/Synthesizer
zdjęcia syntezatorów:
https://www.nordkeyboards.com/
https://pl.wikipedia.org/wiki/Syntezator
https://musiccenter.pl/
Opis dźwięku:
https://pl.wikipedia.org/wiki/Dźwięk
opisy fal:
http://users.cs.cf.ac.uk/Dave.Marshall/CM0268/PDF/07_CM0268_DSP.pdf
https://en.wikipedia.org/wiki/Triangle_wave
https://en.wikipedia.org/wiki/Sawtooth_wave
https://www.youtube.com/watch?v=OSCzKOqtgcA&t=1284s
Opisy SoundMaker:
https://docs.oracle.com/javase/tutorial/sound/sampled-overview.html
opisy efektów:
http://users.cs.cf.ac.uk/Dave.Marshall/CM0268/PDF/10_CM0268_Audio_FX.pdf
MIDI:
https://docs.oracle.com/javase/tutorial/sound/sampled-overview.html
https://www.ibm.com/developerworks/library/it/it-0801art38/
https://www.midi.org/
*/
| t |
8002_2 | Mixeway/MixewayBackend | 2,914 | src/main/java/io/mixeway/utils/SecureRestTemplate.java | package io.mixeway.utils;
import io.mixeway.db.entity.IaasApi;
import io.mixeway.db.entity.Scanner;
import org.apache.http.HttpHost;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import javax.net.ssl.*;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.*;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.time.Duration;
import java.util.function.Supplier;
@Component
public class SecureRestTemplate {
@Value("${server.ssl.key-store}")
private String keyStorePath;
@Value("${server.ssl.key-store-password}")
private String keyStorePassword;
@Value("${server.ssl.trust-store}")
private String trustStorePath;
@Value("${server.ssl.trust-store-password}")
private String trustStorePassword;
public RestTemplate prepareClientWithCertificate(Scanner scanner) throws KeyManagementException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyStoreException, CertificateException, FileNotFoundException, IOException {
KeyStore clientStore = KeyStore.getInstance("PKCS12");
clientStore.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(clientStore, keyStorePassword.toCharArray());
KeyManager[] kms = kmf.getKeyManagers();
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream(trustStorePath), trustStorePassword.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = null;
sslContext = SSLContext.getInstance("TLS");
sslContext.init(kms, tms, new SecureRandom());
CloseableHttpClient httpClient;
if(scanner != null && scanner.getProxies() !=null){
httpClient = HttpClients
.custom()
.setProxy(new HttpHost(scanner.getProxies().getIp(), Integer.parseInt(scanner.getProxies().getPort())))
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.setSSLContext(sslContext)
.build();
}else {
httpClient = HttpClients
.custom()
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.setSSLContext(sslContext)
.build();
}
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
return new RestTemplate(requestFactory);
}
public RestTemplate prepareClientWithCertificateWithoutTimeout(Scanner scanner) throws KeyManagementException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyStoreException, CertificateException, FileNotFoundException, IOException {
KeyStore clientStore = KeyStore.getInstance("PKCS12");
clientStore.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(clientStore, keyStorePassword.toCharArray());
KeyManager[] kms = kmf.getKeyManagers();
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream(trustStorePath), trustStorePassword.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = null;
sslContext = SSLContext.getInstance("TLS");
sslContext.init(kms, tms, new SecureRandom());
CloseableHttpClient httpClient;
if(scanner != null && scanner.getProxies() !=null){
httpClient = HttpClients
.custom()
.setProxy(new HttpHost(scanner.getProxies().getIp(), Integer.parseInt(scanner.getProxies().getPort())))
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.setSSLContext(sslContext)
.build();
}else {
httpClient = HttpClients
.custom()
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.setSSLContext(sslContext)
.build();
}
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
return new RestTemplateBuilder().requestFactory((Supplier<ClientHttpRequestFactory>) requestFactory).setConnectTimeout(Duration.ofMinutes(5)).setReadTimeout(Duration.ofMinutes(5)).build();
//return new RestTemplate(requestFactory);
}
public RestTemplate restTemplateForIaasApi(IaasApi api) throws KeyStoreException, IOException, CertificateException, NoSuchAlgorithmException, KeyManagementException {
//SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream(trustStorePath), trustStorePassword.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = null;
sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tms, new SecureRandom());
HttpClient httpClient;
if (api.getExternal()) {
//TODO zapisanie proxies w iaasapi i wybranie go tutaj
//Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("126.204.4.20", 3128));
httpClient = HttpClients
.custom()
.setProxy(new HttpHost("126.204.4.20", 3128))
.setSSLContext(sslContext)
.build();
//requestFactory.setProxy(proxy);
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
return new RestTemplate(requestFactory);
}
return new RestTemplate();
}
public RestTemplate noVerificationClient(Scanner scanner) throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException{
TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;
SSLContextBuilder sslcontext = new SSLContextBuilder();
HttpClient httpClient;
sslcontext.loadTrustMaterial(null, acceptingTrustStrategy);
if (scanner != null && scanner.getProxies() !=null) {
httpClient = HttpClients.custom()
.setProxy(new HttpHost(scanner.getProxies().getIp(), Integer.parseInt(scanner.getProxies().getPort())))
.setSSLContext(sslcontext.build())
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
} else {
httpClient = HttpClients.custom()
.setSSLContext(sslcontext.build())
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
}
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory() ;
requestFactory.setConnectionRequestTimeout(200000);
requestFactory.setConnectTimeout(200000);
requestFactory.setReadTimeout(200000);
requestFactory.setHttpClient(httpClient);
RestTemplate restTemplate = new RestTemplate(requestFactory);
return restTemplate;
}
public RestTemplate noVerificationClientWithCert(Scanner scanner) throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException, IOException, CertificateException, UnrecoverableKeyException {
TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;
KeyStore clientStore = KeyStore.getInstance("PKCS12");
clientStore.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(clientStore, keyStorePassword.toCharArray());
KeyManager[] kms = kmf.getKeyManagers();
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream(trustStorePath), trustStorePassword.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = null;
sslContext = SSLContext.getInstance("TLS");
sslContext.init(kms, tms, new SecureRandom());
HttpClient httpClient;
if (scanner != null && scanner.getProxies() !=null) {
httpClient = HttpClients.custom()
.setProxy(new HttpHost(scanner.getProxies().getIp(), Integer.parseInt(scanner.getProxies().getPort())))
.setSSLContext(sslContext)
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
} else {
httpClient = HttpClients.custom()
.setSSLContext(sslContext)
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
}
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory() ;
requestFactory.setConnectionRequestTimeout(200000);
requestFactory.setConnectTimeout(200000);
requestFactory.setReadTimeout(200000);
requestFactory.setHttpClient(httpClient);
RestTemplate restTemplate = new RestTemplate(requestFactory);
return restTemplate;
}
public ResponseEntity<Object> executeRequest(RestTemplate restTemplate, HttpMethod method, String url, HttpEntity<Object> entity, Class c){
ResponseEntity<Object> response = restTemplate.exchange(url,method, entity, c);
return response;
}
}
| //TODO zapisanie proxies w iaasapi i wybranie go tutaj | package io.mixeway.utils;
import io.mixeway.db.entity.IaasApi;
import io.mixeway.db.entity.Scanner;
import org.apache.http.HttpHost;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import javax.net.ssl.*;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.*;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.time.Duration;
import java.util.function.Supplier;
@Component
public class SecureRestTemplate {
@Value("${server.ssl.key-store}")
private String keyStorePath;
@Value("${server.ssl.key-store-password}")
private String keyStorePassword;
@Value("${server.ssl.trust-store}")
private String trustStorePath;
@Value("${server.ssl.trust-store-password}")
private String trustStorePassword;
public RestTemplate prepareClientWithCertificate(Scanner scanner) throws KeyManagementException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyStoreException, CertificateException, FileNotFoundException, IOException {
KeyStore clientStore = KeyStore.getInstance("PKCS12");
clientStore.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(clientStore, keyStorePassword.toCharArray());
KeyManager[] kms = kmf.getKeyManagers();
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream(trustStorePath), trustStorePassword.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = null;
sslContext = SSLContext.getInstance("TLS");
sslContext.init(kms, tms, new SecureRandom());
CloseableHttpClient httpClient;
if(scanner != null && scanner.getProxies() !=null){
httpClient = HttpClients
.custom()
.setProxy(new HttpHost(scanner.getProxies().getIp(), Integer.parseInt(scanner.getProxies().getPort())))
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.setSSLContext(sslContext)
.build();
}else {
httpClient = HttpClients
.custom()
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.setSSLContext(sslContext)
.build();
}
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
return new RestTemplate(requestFactory);
}
public RestTemplate prepareClientWithCertificateWithoutTimeout(Scanner scanner) throws KeyManagementException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyStoreException, CertificateException, FileNotFoundException, IOException {
KeyStore clientStore = KeyStore.getInstance("PKCS12");
clientStore.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(clientStore, keyStorePassword.toCharArray());
KeyManager[] kms = kmf.getKeyManagers();
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream(trustStorePath), trustStorePassword.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = null;
sslContext = SSLContext.getInstance("TLS");
sslContext.init(kms, tms, new SecureRandom());
CloseableHttpClient httpClient;
if(scanner != null && scanner.getProxies() !=null){
httpClient = HttpClients
.custom()
.setProxy(new HttpHost(scanner.getProxies().getIp(), Integer.parseInt(scanner.getProxies().getPort())))
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.setSSLContext(sslContext)
.build();
}else {
httpClient = HttpClients
.custom()
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.setSSLContext(sslContext)
.build();
}
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
return new RestTemplateBuilder().requestFactory((Supplier<ClientHttpRequestFactory>) requestFactory).setConnectTimeout(Duration.ofMinutes(5)).setReadTimeout(Duration.ofMinutes(5)).build();
//return new RestTemplate(requestFactory);
}
public RestTemplate restTemplateForIaasApi(IaasApi api) throws KeyStoreException, IOException, CertificateException, NoSuchAlgorithmException, KeyManagementException {
//SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream(trustStorePath), trustStorePassword.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = null;
sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tms, new SecureRandom());
HttpClient httpClient;
if (api.getExternal()) {
//TODO zapisanie <SUF>
//Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("126.204.4.20", 3128));
httpClient = HttpClients
.custom()
.setProxy(new HttpHost("126.204.4.20", 3128))
.setSSLContext(sslContext)
.build();
//requestFactory.setProxy(proxy);
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
return new RestTemplate(requestFactory);
}
return new RestTemplate();
}
public RestTemplate noVerificationClient(Scanner scanner) throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException{
TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;
SSLContextBuilder sslcontext = new SSLContextBuilder();
HttpClient httpClient;
sslcontext.loadTrustMaterial(null, acceptingTrustStrategy);
if (scanner != null && scanner.getProxies() !=null) {
httpClient = HttpClients.custom()
.setProxy(new HttpHost(scanner.getProxies().getIp(), Integer.parseInt(scanner.getProxies().getPort())))
.setSSLContext(sslcontext.build())
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
} else {
httpClient = HttpClients.custom()
.setSSLContext(sslcontext.build())
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
}
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory() ;
requestFactory.setConnectionRequestTimeout(200000);
requestFactory.setConnectTimeout(200000);
requestFactory.setReadTimeout(200000);
requestFactory.setHttpClient(httpClient);
RestTemplate restTemplate = new RestTemplate(requestFactory);
return restTemplate;
}
public RestTemplate noVerificationClientWithCert(Scanner scanner) throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException, IOException, CertificateException, UnrecoverableKeyException {
TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;
KeyStore clientStore = KeyStore.getInstance("PKCS12");
clientStore.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(clientStore, keyStorePassword.toCharArray());
KeyManager[] kms = kmf.getKeyManagers();
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream(trustStorePath), trustStorePassword.toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = null;
sslContext = SSLContext.getInstance("TLS");
sslContext.init(kms, tms, new SecureRandom());
HttpClient httpClient;
if (scanner != null && scanner.getProxies() !=null) {
httpClient = HttpClients.custom()
.setProxy(new HttpHost(scanner.getProxies().getIp(), Integer.parseInt(scanner.getProxies().getPort())))
.setSSLContext(sslContext)
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
} else {
httpClient = HttpClients.custom()
.setSSLContext(sslContext)
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
}
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory() ;
requestFactory.setConnectionRequestTimeout(200000);
requestFactory.setConnectTimeout(200000);
requestFactory.setReadTimeout(200000);
requestFactory.setHttpClient(httpClient);
RestTemplate restTemplate = new RestTemplate(requestFactory);
return restTemplate;
}
public ResponseEntity<Object> executeRequest(RestTemplate restTemplate, HttpMethod method, String url, HttpEntity<Object> entity, Class c){
ResponseEntity<Object> response = restTemplate.exchange(url,method, entity, c);
return response;
}
}
| t |
2462_11 | MnichPawel/stdos | 1,067 | Gotowy_system/STD_OS/src/stdos/Semaphore/JPmetody.java | package stdos.Semaphore;
import stdos.Processes.PCB;
import stdos.Processes.ProcessState;
import stdos.Filesystem.Pliki;
import stdos.Filesystem.Plik;
import static stdos.CPU.CPU.*;
import static stdos.CPU.CPU.MM_getRUNNING;
import static stdos.Processes.ProcessManager.KM_setProcessState;
import java.util.ArrayDeque;
import java.util.Deque;
public class JPmetody {
private static void wakeup(PCB p){
KM_setProcessState (p, ProcessState.READY);//zmiana stanu procesu na ready
//^ oraz dodanie procesu do listy kolejek priorytetowych
}
private static void block(PCB p){
System.out.println("Semafor; zmiana stanu procesu na WAITING");
KM_setProcessState (p, ProcessState.WAITING);//zmiana stanu procesu na waiting
//^ oraz usuniecie procesu z listy kolejek priorytetowych
}
public static void signal(semafor S){
S.wartosc+=1;
if(S.wartosc<=0) {
PCB pom = S.kolejka.poll();
wakeup(pom);
}
}
public static void wait(semafor S){
S.wartosc-=1;
if(S.wartosc<0) {
block(MM_getRUNNING());
S.kolejka.offer(MM_getRUNNING());
}
}
//================================================wypisywanie semafora na ekran=====================================
public static void JPwypisz(String nazwa) throws Exception { //wypisanie wartosci semafora
Plik P = Pliki.KP_dlaJP(nazwa);
if(P!=null) {
System.out.println(P.sem.wartosc);
}
else{
throw new Exception("Bledna nazwa pliku");
}
}
public static void JPwypiszKolejke(String nazwa) throws Exception { //wypisanie wartosci semafora
Plik P = Pliki.KP_dlaJP(nazwa);
if(P==null) {
throw new Exception("Bledna nazwa pliku");
}
else{
Deque<PCB> pom = P.sem.kolejka.clone(); //kopiowanie by zabezpieczyć się przed utratą zawartości oryginalnej kolejki
PCB pompcb;
if(pom.size()==0){
System.out.println("Kolejka jest pusta");
}
else {
for (int i = 0; i < pom.size(); i++) {
pompcb = pom.pollFirst();
System.out.println(pompcb.getPid() + " " + pompcb.getPn());
}
}
}
}
//================================================== wyswietlanie; funkcje ogolne, raczej nie beda uzywane=======================
public static void JPwypiszOgolne(semafor S){ //wypisanie wartosci semafora zakladajaca ze semafory sa nie tylko w plikach
System.out.println(S.wartosc);
}
public static void JPwypiszKolejkeOgolne(semafor S){ //wypisanie wartosci semafora, wersja zakladajaca ze semafory sa nie tylko w plikach
Deque<PCB> pom = S.kolejka.clone(); //kopiowanie by zabezpieczyć się przed utratą zawartości oryginalnej kolejki
PCB pompcb;
for(int i=0; i<pom.size();i++){
pompcb=pom.pollFirst();
System.out.println(pompcb.getPid()+" "+pompcb.getPn());
}
}
}
| //kopiowanie by zabezpieczyć się przed utratą zawartości oryginalnej kolejki | package stdos.Semaphore;
import stdos.Processes.PCB;
import stdos.Processes.ProcessState;
import stdos.Filesystem.Pliki;
import stdos.Filesystem.Plik;
import static stdos.CPU.CPU.*;
import static stdos.CPU.CPU.MM_getRUNNING;
import static stdos.Processes.ProcessManager.KM_setProcessState;
import java.util.ArrayDeque;
import java.util.Deque;
public class JPmetody {
private static void wakeup(PCB p){
KM_setProcessState (p, ProcessState.READY);//zmiana stanu procesu na ready
//^ oraz dodanie procesu do listy kolejek priorytetowych
}
private static void block(PCB p){
System.out.println("Semafor; zmiana stanu procesu na WAITING");
KM_setProcessState (p, ProcessState.WAITING);//zmiana stanu procesu na waiting
//^ oraz usuniecie procesu z listy kolejek priorytetowych
}
public static void signal(semafor S){
S.wartosc+=1;
if(S.wartosc<=0) {
PCB pom = S.kolejka.poll();
wakeup(pom);
}
}
public static void wait(semafor S){
S.wartosc-=1;
if(S.wartosc<0) {
block(MM_getRUNNING());
S.kolejka.offer(MM_getRUNNING());
}
}
//================================================wypisywanie semafora na ekran=====================================
public static void JPwypisz(String nazwa) throws Exception { //wypisanie wartosci semafora
Plik P = Pliki.KP_dlaJP(nazwa);
if(P!=null) {
System.out.println(P.sem.wartosc);
}
else{
throw new Exception("Bledna nazwa pliku");
}
}
public static void JPwypiszKolejke(String nazwa) throws Exception { //wypisanie wartosci semafora
Plik P = Pliki.KP_dlaJP(nazwa);
if(P==null) {
throw new Exception("Bledna nazwa pliku");
}
else{
Deque<PCB> pom = P.sem.kolejka.clone(); //kopiowanie by zabezpieczyć się przed utratą zawartości oryginalnej kolejki
PCB pompcb;
if(pom.size()==0){
System.out.println("Kolejka jest pusta");
}
else {
for (int i = 0; i < pom.size(); i++) {
pompcb = pom.pollFirst();
System.out.println(pompcb.getPid() + " " + pompcb.getPn());
}
}
}
}
//================================================== wyswietlanie; funkcje ogolne, raczej nie beda uzywane=======================
public static void JPwypiszOgolne(semafor S){ //wypisanie wartosci semafora zakladajaca ze semafory sa nie tylko w plikach
System.out.println(S.wartosc);
}
public static void JPwypiszKolejkeOgolne(semafor S){ //wypisanie wartosci semafora, wersja zakladajaca ze semafory sa nie tylko w plikach
Deque<PCB> pom = S.kolejka.clone(); //kopiowanie by <SUF>
PCB pompcb;
for(int i=0; i<pom.size();i++){
pompcb=pom.pollFirst();
System.out.println(pompcb.getPid()+" "+pompcb.getPn());
}
}
}
| t |
10352_8 | Morswin12/zajavka-warsztaty | 829 | src/main/java/WARSZTATY/Warsztat_13_SPRING_BEANS/P_10_Wlasciwosci_Bean_Scope/Main.java | package WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope;
import WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope.code.InjectedBean;
import WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope.configuration.ExampleConfigurationClass;
import WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope.configuration.ExamplePrototypeBean;
import WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope.configuration.ExampleSingletonBean;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
public class Main {
// Scopes - zakresy beanów:
// 1. Podstawowe:
// Singleton -> (domyślnie wszystkie beany w Springu są Singletonami),czyli za każdym razem, gdy będę pobierał
// bina tego samego typu (np. context.getBean(SomeClass.class) to będzie to ten sam obiekt.
// Prototype -> możemy tak ustawić, żeby w przeciwieństwie do beana a ustawieniami domyślnymi, pobieraniu
// beana tego samego typu tworzył się nowy obiekt (prototyp)
// 2. w środowisku webowym:
// Request -> będzie tworzył instancję serwisu per żądanie http
// Session -> jedna instancja serwisu na jedną sesję http;
// Application -> jedną instancję serwisu na serwer context
// WebSocket -> jedna instancja serwisu na web socket
public static void main(String[] args) {
AbstractApplicationContext context = new AnnotationConfigApplicationContext(ExampleConfigurationClass.class);
ExampleSingletonBean singleton1 = context.getBean(ExampleSingletonBean.class);
ExampleSingletonBean singleton2 = context.getBean(ExampleSingletonBean.class);
ExamplePrototypeBean prototype1 = context.getBean(ExamplePrototypeBean.class);
ExamplePrototypeBean prototype2 = context.getBean(ExamplePrototypeBean.class);
System.out.println("singleton1 == singleton2 " + (singleton1 == singleton2));
System.out.println("prototype1 == prototype2 " + (prototype1 == prototype2));
InjectedBean injectedBean = context.getBean(InjectedBean.class);
boolean isInjectedBeanAsSingleton =
injectedBean == singleton1.getInjectedBean()
&& injectedBean == singleton2.getInjectedBean()
&& injectedBean == prototype1.getInjectedBean()
&& injectedBean == prototype2.getInjectedBean();
System.out.println("Is InjectedBean a Singleton? " + isInjectedBeanAsSingleton);
}
}
| // Application -> jedną instancję serwisu na serwer context | package WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope;
import WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope.code.InjectedBean;
import WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope.configuration.ExampleConfigurationClass;
import WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope.configuration.ExamplePrototypeBean;
import WARSZTATY.Warsztat_13_SPRING_BEANS.P_10_Wlasciwosci_Bean_Scope.configuration.ExampleSingletonBean;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
public class Main {
// Scopes - zakresy beanów:
// 1. Podstawowe:
// Singleton -> (domyślnie wszystkie beany w Springu są Singletonami),czyli za każdym razem, gdy będę pobierał
// bina tego samego typu (np. context.getBean(SomeClass.class) to będzie to ten sam obiekt.
// Prototype -> możemy tak ustawić, żeby w przeciwieństwie do beana a ustawieniami domyślnymi, pobieraniu
// beana tego samego typu tworzył się nowy obiekt (prototyp)
// 2. w środowisku webowym:
// Request -> będzie tworzył instancję serwisu per żądanie http
// Session -> jedna instancja serwisu na jedną sesję http;
// Application -> <SUF>
// WebSocket -> jedna instancja serwisu na web socket
public static void main(String[] args) {
AbstractApplicationContext context = new AnnotationConfigApplicationContext(ExampleConfigurationClass.class);
ExampleSingletonBean singleton1 = context.getBean(ExampleSingletonBean.class);
ExampleSingletonBean singleton2 = context.getBean(ExampleSingletonBean.class);
ExamplePrototypeBean prototype1 = context.getBean(ExamplePrototypeBean.class);
ExamplePrototypeBean prototype2 = context.getBean(ExamplePrototypeBean.class);
System.out.println("singleton1 == singleton2 " + (singleton1 == singleton2));
System.out.println("prototype1 == prototype2 " + (prototype1 == prototype2));
InjectedBean injectedBean = context.getBean(InjectedBean.class);
boolean isInjectedBeanAsSingleton =
injectedBean == singleton1.getInjectedBean()
&& injectedBean == singleton2.getInjectedBean()
&& injectedBean == prototype1.getInjectedBean()
&& injectedBean == prototype2.getInjectedBean();
System.out.println("Is InjectedBean a Singleton? " + isInjectedBeanAsSingleton);
}
}
| t |
3385_0 | MrGrzesiek/weatherAPP | 597 | app/src/main/java/com/example/weather/MainActivity.java | package com.example.weather;
import android.os.Bundle;
import androidx.activity.OnBackPressedCallback;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentPagerAdapter;
import androidx.viewpager.widget.ViewPager;
public class MainActivity extends AppCompatActivity implements SimpleDataFragment.SendMessage{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ViewPager viewPager = findViewById(R.id.viewPager);
MyPagerAdapter pagerAdapter = new MyPagerAdapter(getSupportFragmentManager());
viewPager.setAdapter(pagerAdapter);
// Dodaj obsługę przycisku wstecz
OnBackPressedCallback callback = new OnBackPressedCallback(true) {
@Override
public void handleOnBackPressed() {
if (viewPager.getCurrentItem() > 0) {
viewPager.setCurrentItem(viewPager.getCurrentItem() - 1);
} else {
// Jeśli jesteś na pierwszym fragmencie, zakończ aktywność
finish();
}
}
};
getOnBackPressedDispatcher().addCallback(this, callback);
}
private static class MyPagerAdapter extends FragmentPagerAdapter {
MyPagerAdapter(FragmentManager fragmentManager) {
super(fragmentManager);
}
@Override
public Fragment getItem(int position) {
switch (position) {
case 0:
return new SimpleDataFragment();
case 1:
return new MoreDataFragment();
case 2:
return new NextDayWeatherFragment();
default:
return null;
}
}
@Override
public int getCount() {
return 3;
}
}
@Override
public void sendData(double windSpeed, double windDeg, int visibility, int humidity) {
String tag = "android:switcher:" + R.id.viewPager + ":" + 1;
MoreDataFragment f = (MoreDataFragment) getSupportFragmentManager().findFragmentByTag(tag);
f.displayReceivedData(windSpeed, windDeg, visibility, humidity);
}
}
| // Dodaj obsługę przycisku wstecz | package com.example.weather;
import android.os.Bundle;
import androidx.activity.OnBackPressedCallback;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentPagerAdapter;
import androidx.viewpager.widget.ViewPager;
public class MainActivity extends AppCompatActivity implements SimpleDataFragment.SendMessage{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ViewPager viewPager = findViewById(R.id.viewPager);
MyPagerAdapter pagerAdapter = new MyPagerAdapter(getSupportFragmentManager());
viewPager.setAdapter(pagerAdapter);
// Dodaj obsługę <SUF>
OnBackPressedCallback callback = new OnBackPressedCallback(true) {
@Override
public void handleOnBackPressed() {
if (viewPager.getCurrentItem() > 0) {
viewPager.setCurrentItem(viewPager.getCurrentItem() - 1);
} else {
// Jeśli jesteś na pierwszym fragmencie, zakończ aktywność
finish();
}
}
};
getOnBackPressedDispatcher().addCallback(this, callback);
}
private static class MyPagerAdapter extends FragmentPagerAdapter {
MyPagerAdapter(FragmentManager fragmentManager) {
super(fragmentManager);
}
@Override
public Fragment getItem(int position) {
switch (position) {
case 0:
return new SimpleDataFragment();
case 1:
return new MoreDataFragment();
case 2:
return new NextDayWeatherFragment();
default:
return null;
}
}
@Override
public int getCount() {
return 3;
}
}
@Override
public void sendData(double windSpeed, double windDeg, int visibility, int humidity) {
String tag = "android:switcher:" + R.id.viewPager + ":" + 1;
MoreDataFragment f = (MoreDataFragment) getSupportFragmentManager().findFragmentByTag(tag);
f.displayReceivedData(windSpeed, windDeg, visibility, humidity);
}
}
| t |
9142_6 | MyKarcio123/OOPlab | 4,099 | proj1/src/main/java/agh/ics/oop/AbstractWorldMap.java | package agh.ics.oop;
import com.google.common.collect.MultimapBuilder;
import com.google.common.collect.SetMultimap;
import java.util.*;
import java.util.stream.Stream;
import static agh.ics.oop.PlaceInitGrass.placeGrass;
import static agh.ics.oop.RandomPosition.*;
public abstract class AbstractWorldMap implements IWorldMap, IAnimalStateMapObserver {
protected final SetMultimap<Vector2d, Animal> animalMap;
protected final Map<Vector2d, Grass> grassMap;
protected final MapVisualizer mapVisualizer;
private final Set<Vector2d> placesOfGrassToBeEaten;
private final Set<Vector2d> placesOfCopulation;
private final HashMap<Vector2d, Integer> deathAnimals;
private HashMap<Vector2d, Integer> historyOfDeathAnimals = new HashMap<>();
private HashMap<List<Integer>, Integer> popularGenotypes = new HashMap<>();
private final Vector2d mapUpperRight;
private final Vector2d mapLowerLeft = new Vector2d(1, 1);
private int howManydied = 0;
private int sumOfDiedAge = 0;
private Animal animalToShow = null;
public Animal getAnimalToShow() {
return animalToShow;
}
@Override
public void setAnimalToShow(Animal animal) {
this.animalToShow = animal;
}
private final IMapStateEngineObserver observer;
private final DataParameters dataParameters;
public Biomes getBiomes() {
return biomes;
}
protected Biomes biomes;
protected AbstractWorldMap(IMapStateEngineObserver observer, DataParameters currentConfig) {
animalMap = MultimapBuilder.hashKeys().treeSetValues().build();
grassMap = new HashMap<>();
mapVisualizer = new MapVisualizer(this);
placesOfGrassToBeEaten = new HashSet<>();
deathAnimals = new HashMap<>();
dataParameters = currentConfig;
mapUpperRight = new Vector2d(dataParameters.getWidth(), dataParameters.getHeight());
this.observer = observer;
if (dataParameters.getGrassGrowVariant() == 1) {
historyOfDeathAnimals = new HashMap<>();
for (int i = mapLowerLeft.getX(); i <= mapUpperRight.getX(); i++) {
for (int j = mapLowerLeft.getY(); j <= mapUpperRight.getY(); j++) {
historyOfDeathAnimals.put(new Vector2d(i, j), 0);
}
}
}else if(dataParameters.getGrassGrowVariant() == 2){
NoiseData temperature = new NoiseData(dataParameters.getWidth(),dataParameters.getHeight(),0.1,0.09,8,1);
NoiseData rainfall = new NoiseData(dataParameters.getWidth(),dataParameters.getHeight(),0.3,0.2,8,1);
biomes = new Biomes(temperature,rainfall,0,4);
}
placesOfCopulation = new HashSet<>();
placeInitGrass(dataParameters.getStartingGrass());
}
public DataParameters getDataParameters() {
return this.dataParameters;
}
private void placeInitGrass(int amount) {
List<Vector2d> placesOfGrass = placeGrass(this, amount, dataParameters.getGrassGrowVariant());
for (Vector2d grassPosition : placesOfGrass) {
grassMap.put(grassPosition, new Grass(grassPosition));
}
}
public HashMap<Vector2d, Integer> getHistoryOfDeathAnimals() {
return historyOfDeathAnimals;
}
@Override
public String toString() {
return mapVisualizer.draw(this.getMapLowerLeft(), this.getMapUpperRight());
}
public Vector2d getMapLowerLeft() {
return this.mapLowerLeft;
}
public Vector2d getMapUpperRight() {
return this.mapUpperRight;
}
public boolean isOccupied(Vector2d position) {
return (animalMap.containsKey(position));
}
public void clearDeathAnimals() {
for (Map.Entry<Vector2d, Integer> set : deathAnimals.entrySet()) {
Vector2d pos = set.getKey();
Integer amt = set.getValue();
Integer histAmt = historyOfDeathAnimals.get(pos);
if (histAmt == null) {
historyOfDeathAnimals.put(pos, amt);
} else {
historyOfDeathAnimals.replace(pos, histAmt + amt);
}
NavigableSet<Animal> animals = objectAt(pos);
for (int i = 0; i < amt; i++) {
animals.pollLast();
}
}
deathAnimals.clear();
}
public boolean isOccupiedByGrass(Vector2d position) {
return (grassMap.containsKey(position));
}
//Logiczne uzasadnienie czeemu do dieEvent przekazuję tylko współrzędne mimo że pod jedną współrzędną w mapie może być n obiektów.
//Jest to spowodwane tym, że w mapie zwierząt jest coś ala TreeSet którego pierwszym kryterium jest energia malejąco.
//Z tego faktu wynika że nie muszę wiedzieć dokładnie które zwierzę umarło ale ile, bo będę od końca usuwał konieczną ilość zwierząt.
@Override
public void dieEvent(Vector2d position, int day) {
howManydied+=1;
sumOfDiedAge += day;
if (deathAnimals.containsKey(position)) {
deathAnimals.merge(position,1,Integer::sum);
}else {
deathAnimals.put(position, 1);
}
}
public int getNumberOfAnimals(){
return animalMap.size();
}
public int getAmountOfGrass(){
return grassMap.size();
}
public Integer getAmountOfAnimalsDead(){
return historyOfDeathAnimals.values().stream().reduce(0, Integer::sum);
}
public Integer getFreePlaces(){
int width = mapUpperRight.getX() - mapLowerLeft.getX();
int height = mapUpperRight.getY() - mapLowerLeft.getY();
return width*height - animalMap.size() - grassMap.size();
}
public List<Integer> getPopularGenotype(){
popularGenotypes.clear();
for(Animal animal : animalMap.values()){
List<Integer> genotype = animal.getGenotype();
if (popularGenotypes.containsKey(genotype)) {
popularGenotypes.merge(genotype,1,Integer::sum);
}else {
popularGenotypes.put(genotype, 1);
}
}
Integer maxx = 0;
List<Integer> output = new ArrayList<>();
for (List<Integer> genotype : popularGenotypes.keySet()){
if (popularGenotypes.get(genotype)>maxx){
maxx = popularGenotypes.get(genotype);
output = genotype;
}
}
return output;
}
public Float getAverageEnergy(){
int sumOfEnergy = 0;
for (Animal animal : animalMap.values()){
sumOfEnergy += animal.getEnergy();
}
return sumOfEnergy/ (float) animalMap.size();
}
public Float getAverageLifeTime(){
return sumOfDiedAge/(float) howManydied;
}
@Override
public int eatGrass() {
int howManyGrassRemoved = 0;
for (Vector2d pos : placesOfGrassToBeEaten) {
if (grassMap.containsKey(pos)) {
NavigableSet<Animal> animalsSet = objectAt(pos);
Animal animal = animalsSet.first();
animal.gainEnergy();
animal.grassCounter();
grassMap.remove(pos);
howManyGrassRemoved += 1;
}
}
placesOfGrassToBeEaten.clear();
return howManyGrassRemoved;
}
public Map<Vector2d, Grass> getGrassMap() {
return grassMap;
}
@Override
public void copulateAnimals() {
for (Vector2d pos : placesOfCopulation) {
NavigableSet<Animal> animalsSet = objectAt(pos);
if (animalsSet.size() > 1) {
Animal animal1 = animalsSet.pollFirst();
Animal animal2 = animalsSet.pollFirst();
if (animal2.canCopulate()) {
//TODO powymyślać stałe, bo poniżej wpisałem losowe liczby- jakie stałe jak to mają być losowo generowane liczby XD?
// ty w ogóle czytałeś te wypociny na gitubie XD poprawiłem trochę tą funkcję bo
// 1. nowy animal nie może być Tworzony w mapie, bo Engine go potrzebuje
// 2. nie masz licznika dni w tym scope
// TODO piszę wszystko w todo bo ładny kolorek ma
//TODO czytałem, ale zapomniałem pusha zrobić przed kościołem i jakieś starocie były w tym miejscu
//krok 1 - losowanie strony
int mutationSite = getBinaryDigit();
// krok 2 - zbieranie genów
List<Integer> genotype1;
List<Integer> genotype2;
int sumOfEnergies = animal1.getEnergy() + animal2.getEnergy();
int genotypeSize = animal1.getGenotypeSize();
int infiriorGenotypeSize = 0;
if (animal1.getEnergy() > animal2.getEnergy()) {
infiriorGenotypeSize = animal2.getEnergy() / sumOfEnergies;
} else {
infiriorGenotypeSize = animal1.getEnergy() / sumOfEnergies;
}
int superiorGenotypeSize = genotypeSize - infiriorGenotypeSize;
if (mutationSite == 0) {
if (animal1.getEnergy() > animal2.getEnergy()) {
genotype1 = animal2.copulate(1, superiorGenotypeSize);
genotype2 = animal1.copulate(0, infiriorGenotypeSize);
} else {
genotype1 = animal2.copulate(1, infiriorGenotypeSize);
genotype2 = animal1.copulate(0, superiorGenotypeSize);
}
} else {
if (animal1.getEnergy() > animal2.getEnergy()) {
genotype1 = animal1.copulate(1, superiorGenotypeSize);
genotype2 = animal2.copulate(0, infiriorGenotypeSize);
} else {
genotype1 = animal1.copulate(1, infiriorGenotypeSize);
genotype2 = animal2.copulate(0, superiorGenotypeSize);
}
}
List<Integer> genotype = new ArrayList<>(Stream.concat(genotype1.stream(), genotype2.stream()).toList());
//krok 3- robienie mutacji na genotypie
List<Integer> indexesOfGenesToChange = getListOfIndexesOfGenesToChange(genotype.size());
if (dataParameters.getMutationVariant() == 0) {
for (Integer index : indexesOfGenesToChange) {
genotype.set(index, getRandomGene());
}
} else if (dataParameters.getMutationVariant() == 1) {
for (Integer index : indexesOfGenesToChange) {
int geneChange;
if (getBinaryDigit() == 0) {
geneChange = -1;
} else {
geneChange = 1;
}
int newGene = genotype.get(index) + geneChange;
if (newGene < 0) newGene = 7;
if (newGene > 7) newGene = 0;
genotype.set(index, newGene);
}
}
//krok 4 - zrobienie dziecka
Animal child = observer.bornEvent(this, pos, genotype);
animalMap.put(pos, child);
}
animalMap.put(pos, animal1);
animalMap.put(pos, animal2);
}
}
placesOfCopulation.clear();
}
@Override
public void plantGrass(int howManyGrassToAdd) {
placeInitGrass(howManyGrassToAdd);
}
@Override
public Vector2d positionChanged(Vector2d oldPosition, Vector2d newPosition, int id) {
NavigableSet<Animal> animals = objectAt(oldPosition);
Animal currentAnimal = null;
for (Animal animal : animals) {
if (animal.getID() == id) {
currentAnimal = animal;
break;
}
}
//do końca życia już tego nie zapomne
Animal finalCurrentAnimal = currentAnimal;
animals.removeIf(animal -> animal.getID() == finalCurrentAnimal.getID());
if (canMoveTo(newPosition)) {
currentAnimal.lowerEnergy(newPosition);
animalMap.put(newPosition, currentAnimal);
} else {
newPosition = getNewPosition(newPosition);
if (newPosition == null) {
if (animalMap.get(oldPosition).size() >= 2) {
placesOfCopulation.add(oldPosition);
}
currentAnimal.lowerEnergy(oldPosition);
animalMap.put(oldPosition, currentAnimal);
return oldPosition;
}
currentAnimal.lowerEnergy(newPosition);
animalMap.put(newPosition, currentAnimal);
}
if (animalMap.get(newPosition).size() == 2) {
placesOfCopulation.add(newPosition);
}
if (grassMap.containsKey(newPosition)) {
placesOfGrassToBeEaten.add(newPosition);
}
return newPosition;
}
@Override
public NavigableSet<Animal> objectAt(Vector2d pos) {
return (NavigableSet<Animal>) animalMap.get(pos);
}
@Override
public boolean place(Animal animal) {
animalMap.put(animal.getPosition(), animal);
return true;
}
public BiomeType getBiomeFromMap(Vector2d pos){
return biomes.getBiomeTypeAt(pos);
}
public HashMap<Vector2d, Integer> getDeathAnimals(){
return deathAnimals;
}
public Set<Vector2d> getPlacesOfCopulation(){
return placesOfCopulation;
}
public SetMultimap<Vector2d, Animal> getAnimalMap(){
return animalMap;
}
}
| // 2. nie masz licznika dni w tym scope | package agh.ics.oop;
import com.google.common.collect.MultimapBuilder;
import com.google.common.collect.SetMultimap;
import java.util.*;
import java.util.stream.Stream;
import static agh.ics.oop.PlaceInitGrass.placeGrass;
import static agh.ics.oop.RandomPosition.*;
public abstract class AbstractWorldMap implements IWorldMap, IAnimalStateMapObserver {
protected final SetMultimap<Vector2d, Animal> animalMap;
protected final Map<Vector2d, Grass> grassMap;
protected final MapVisualizer mapVisualizer;
private final Set<Vector2d> placesOfGrassToBeEaten;
private final Set<Vector2d> placesOfCopulation;
private final HashMap<Vector2d, Integer> deathAnimals;
private HashMap<Vector2d, Integer> historyOfDeathAnimals = new HashMap<>();
private HashMap<List<Integer>, Integer> popularGenotypes = new HashMap<>();
private final Vector2d mapUpperRight;
private final Vector2d mapLowerLeft = new Vector2d(1, 1);
private int howManydied = 0;
private int sumOfDiedAge = 0;
private Animal animalToShow = null;
public Animal getAnimalToShow() {
return animalToShow;
}
@Override
public void setAnimalToShow(Animal animal) {
this.animalToShow = animal;
}
private final IMapStateEngineObserver observer;
private final DataParameters dataParameters;
public Biomes getBiomes() {
return biomes;
}
protected Biomes biomes;
protected AbstractWorldMap(IMapStateEngineObserver observer, DataParameters currentConfig) {
animalMap = MultimapBuilder.hashKeys().treeSetValues().build();
grassMap = new HashMap<>();
mapVisualizer = new MapVisualizer(this);
placesOfGrassToBeEaten = new HashSet<>();
deathAnimals = new HashMap<>();
dataParameters = currentConfig;
mapUpperRight = new Vector2d(dataParameters.getWidth(), dataParameters.getHeight());
this.observer = observer;
if (dataParameters.getGrassGrowVariant() == 1) {
historyOfDeathAnimals = new HashMap<>();
for (int i = mapLowerLeft.getX(); i <= mapUpperRight.getX(); i++) {
for (int j = mapLowerLeft.getY(); j <= mapUpperRight.getY(); j++) {
historyOfDeathAnimals.put(new Vector2d(i, j), 0);
}
}
}else if(dataParameters.getGrassGrowVariant() == 2){
NoiseData temperature = new NoiseData(dataParameters.getWidth(),dataParameters.getHeight(),0.1,0.09,8,1);
NoiseData rainfall = new NoiseData(dataParameters.getWidth(),dataParameters.getHeight(),0.3,0.2,8,1);
biomes = new Biomes(temperature,rainfall,0,4);
}
placesOfCopulation = new HashSet<>();
placeInitGrass(dataParameters.getStartingGrass());
}
public DataParameters getDataParameters() {
return this.dataParameters;
}
private void placeInitGrass(int amount) {
List<Vector2d> placesOfGrass = placeGrass(this, amount, dataParameters.getGrassGrowVariant());
for (Vector2d grassPosition : placesOfGrass) {
grassMap.put(grassPosition, new Grass(grassPosition));
}
}
public HashMap<Vector2d, Integer> getHistoryOfDeathAnimals() {
return historyOfDeathAnimals;
}
@Override
public String toString() {
return mapVisualizer.draw(this.getMapLowerLeft(), this.getMapUpperRight());
}
public Vector2d getMapLowerLeft() {
return this.mapLowerLeft;
}
public Vector2d getMapUpperRight() {
return this.mapUpperRight;
}
public boolean isOccupied(Vector2d position) {
return (animalMap.containsKey(position));
}
public void clearDeathAnimals() {
for (Map.Entry<Vector2d, Integer> set : deathAnimals.entrySet()) {
Vector2d pos = set.getKey();
Integer amt = set.getValue();
Integer histAmt = historyOfDeathAnimals.get(pos);
if (histAmt == null) {
historyOfDeathAnimals.put(pos, amt);
} else {
historyOfDeathAnimals.replace(pos, histAmt + amt);
}
NavigableSet<Animal> animals = objectAt(pos);
for (int i = 0; i < amt; i++) {
animals.pollLast();
}
}
deathAnimals.clear();
}
public boolean isOccupiedByGrass(Vector2d position) {
return (grassMap.containsKey(position));
}
//Logiczne uzasadnienie czeemu do dieEvent przekazuję tylko współrzędne mimo że pod jedną współrzędną w mapie może być n obiektów.
//Jest to spowodwane tym, że w mapie zwierząt jest coś ala TreeSet którego pierwszym kryterium jest energia malejąco.
//Z tego faktu wynika że nie muszę wiedzieć dokładnie które zwierzę umarło ale ile, bo będę od końca usuwał konieczną ilość zwierząt.
@Override
public void dieEvent(Vector2d position, int day) {
howManydied+=1;
sumOfDiedAge += day;
if (deathAnimals.containsKey(position)) {
deathAnimals.merge(position,1,Integer::sum);
}else {
deathAnimals.put(position, 1);
}
}
public int getNumberOfAnimals(){
return animalMap.size();
}
public int getAmountOfGrass(){
return grassMap.size();
}
public Integer getAmountOfAnimalsDead(){
return historyOfDeathAnimals.values().stream().reduce(0, Integer::sum);
}
public Integer getFreePlaces(){
int width = mapUpperRight.getX() - mapLowerLeft.getX();
int height = mapUpperRight.getY() - mapLowerLeft.getY();
return width*height - animalMap.size() - grassMap.size();
}
public List<Integer> getPopularGenotype(){
popularGenotypes.clear();
for(Animal animal : animalMap.values()){
List<Integer> genotype = animal.getGenotype();
if (popularGenotypes.containsKey(genotype)) {
popularGenotypes.merge(genotype,1,Integer::sum);
}else {
popularGenotypes.put(genotype, 1);
}
}
Integer maxx = 0;
List<Integer> output = new ArrayList<>();
for (List<Integer> genotype : popularGenotypes.keySet()){
if (popularGenotypes.get(genotype)>maxx){
maxx = popularGenotypes.get(genotype);
output = genotype;
}
}
return output;
}
public Float getAverageEnergy(){
int sumOfEnergy = 0;
for (Animal animal : animalMap.values()){
sumOfEnergy += animal.getEnergy();
}
return sumOfEnergy/ (float) animalMap.size();
}
public Float getAverageLifeTime(){
return sumOfDiedAge/(float) howManydied;
}
@Override
public int eatGrass() {
int howManyGrassRemoved = 0;
for (Vector2d pos : placesOfGrassToBeEaten) {
if (grassMap.containsKey(pos)) {
NavigableSet<Animal> animalsSet = objectAt(pos);
Animal animal = animalsSet.first();
animal.gainEnergy();
animal.grassCounter();
grassMap.remove(pos);
howManyGrassRemoved += 1;
}
}
placesOfGrassToBeEaten.clear();
return howManyGrassRemoved;
}
public Map<Vector2d, Grass> getGrassMap() {
return grassMap;
}
@Override
public void copulateAnimals() {
for (Vector2d pos : placesOfCopulation) {
NavigableSet<Animal> animalsSet = objectAt(pos);
if (animalsSet.size() > 1) {
Animal animal1 = animalsSet.pollFirst();
Animal animal2 = animalsSet.pollFirst();
if (animal2.canCopulate()) {
//TODO powymyślać stałe, bo poniżej wpisałem losowe liczby- jakie stałe jak to mają być losowo generowane liczby XD?
// ty w ogóle czytałeś te wypociny na gitubie XD poprawiłem trochę tą funkcję bo
// 1. nowy animal nie może być Tworzony w mapie, bo Engine go potrzebuje
// 2. nie <SUF>
// TODO piszę wszystko w todo bo ładny kolorek ma
//TODO czytałem, ale zapomniałem pusha zrobić przed kościołem i jakieś starocie były w tym miejscu
//krok 1 - losowanie strony
int mutationSite = getBinaryDigit();
// krok 2 - zbieranie genów
List<Integer> genotype1;
List<Integer> genotype2;
int sumOfEnergies = animal1.getEnergy() + animal2.getEnergy();
int genotypeSize = animal1.getGenotypeSize();
int infiriorGenotypeSize = 0;
if (animal1.getEnergy() > animal2.getEnergy()) {
infiriorGenotypeSize = animal2.getEnergy() / sumOfEnergies;
} else {
infiriorGenotypeSize = animal1.getEnergy() / sumOfEnergies;
}
int superiorGenotypeSize = genotypeSize - infiriorGenotypeSize;
if (mutationSite == 0) {
if (animal1.getEnergy() > animal2.getEnergy()) {
genotype1 = animal2.copulate(1, superiorGenotypeSize);
genotype2 = animal1.copulate(0, infiriorGenotypeSize);
} else {
genotype1 = animal2.copulate(1, infiriorGenotypeSize);
genotype2 = animal1.copulate(0, superiorGenotypeSize);
}
} else {
if (animal1.getEnergy() > animal2.getEnergy()) {
genotype1 = animal1.copulate(1, superiorGenotypeSize);
genotype2 = animal2.copulate(0, infiriorGenotypeSize);
} else {
genotype1 = animal1.copulate(1, infiriorGenotypeSize);
genotype2 = animal2.copulate(0, superiorGenotypeSize);
}
}
List<Integer> genotype = new ArrayList<>(Stream.concat(genotype1.stream(), genotype2.stream()).toList());
//krok 3- robienie mutacji na genotypie
List<Integer> indexesOfGenesToChange = getListOfIndexesOfGenesToChange(genotype.size());
if (dataParameters.getMutationVariant() == 0) {
for (Integer index : indexesOfGenesToChange) {
genotype.set(index, getRandomGene());
}
} else if (dataParameters.getMutationVariant() == 1) {
for (Integer index : indexesOfGenesToChange) {
int geneChange;
if (getBinaryDigit() == 0) {
geneChange = -1;
} else {
geneChange = 1;
}
int newGene = genotype.get(index) + geneChange;
if (newGene < 0) newGene = 7;
if (newGene > 7) newGene = 0;
genotype.set(index, newGene);
}
}
//krok 4 - zrobienie dziecka
Animal child = observer.bornEvent(this, pos, genotype);
animalMap.put(pos, child);
}
animalMap.put(pos, animal1);
animalMap.put(pos, animal2);
}
}
placesOfCopulation.clear();
}
@Override
public void plantGrass(int howManyGrassToAdd) {
placeInitGrass(howManyGrassToAdd);
}
@Override
public Vector2d positionChanged(Vector2d oldPosition, Vector2d newPosition, int id) {
NavigableSet<Animal> animals = objectAt(oldPosition);
Animal currentAnimal = null;
for (Animal animal : animals) {
if (animal.getID() == id) {
currentAnimal = animal;
break;
}
}
//do końca życia już tego nie zapomne
Animal finalCurrentAnimal = currentAnimal;
animals.removeIf(animal -> animal.getID() == finalCurrentAnimal.getID());
if (canMoveTo(newPosition)) {
currentAnimal.lowerEnergy(newPosition);
animalMap.put(newPosition, currentAnimal);
} else {
newPosition = getNewPosition(newPosition);
if (newPosition == null) {
if (animalMap.get(oldPosition).size() >= 2) {
placesOfCopulation.add(oldPosition);
}
currentAnimal.lowerEnergy(oldPosition);
animalMap.put(oldPosition, currentAnimal);
return oldPosition;
}
currentAnimal.lowerEnergy(newPosition);
animalMap.put(newPosition, currentAnimal);
}
if (animalMap.get(newPosition).size() == 2) {
placesOfCopulation.add(newPosition);
}
if (grassMap.containsKey(newPosition)) {
placesOfGrassToBeEaten.add(newPosition);
}
return newPosition;
}
@Override
public NavigableSet<Animal> objectAt(Vector2d pos) {
return (NavigableSet<Animal>) animalMap.get(pos);
}
@Override
public boolean place(Animal animal) {
animalMap.put(animal.getPosition(), animal);
return true;
}
public BiomeType getBiomeFromMap(Vector2d pos){
return biomes.getBiomeTypeAt(pos);
}
public HashMap<Vector2d, Integer> getDeathAnimals(){
return deathAnimals;
}
public Set<Vector2d> getPlacesOfCopulation(){
return placesOfCopulation;
}
public SetMultimap<Vector2d, Animal> getAnimalMap(){
return animalMap;
}
}
| t |
4093_0 | NajlepszyZespolZJavy/ksiazkaKucharska | 619 | src/main/java/Nalesniki.java | import java.net.URL;
/**
* Klasa naleśników. Dziedziczy z Przepisu i nadpisuje wszystkie jego metody
*/
public class Nalesniki extends Przepis {
String tytul = "Naleśniki";
URL sciezkaGrafiki = Nalesniki.class.getResource("grafiki/nalesniki.jpg");
String czasWykonania = "Czas wykonania: 20 minut";
String trudnoscWykonania = "Trudność wykonania: łatwa";
String skladniki = "<html>Składniki:<br>" +
"250ml mąki pszennej<br>" +
"190ml wody (najlepiej gazowanej)<br>" +
"2 jajka<br>" +
"250ml mleka<br>" +
"szczypta soli<br>" +
"3 łyżki masła lub oleju roślinnego";
String instrukcje = "<html>Instrukcje:<br>" +
"1) Mąkę wsypać do miski, dodać jajka, mleko, wodę i sól.<br>" +
"2) Zmiksować na gładkie ciasto.<br>" +
"3) Dodać roztopione masło lub olej roślinny i razem zmiksować<br>" +
"(lub wykorzystać tłuszcz do smarowania patelni przed smażeniem<br>każdego naleśnika).<br>" +
"4) Naleśniki smażyć na dobrze rozgrzanej patelni z cienkim dnem np. naleśnikowej. " +
"Przewrócić na drugą stronę gdy spód naleśnika będzie już ładnie zrumieniony i ścięty.";
protected String getTytul() { return tytul; }
protected URL getSciezkaGrafiki() { return sciezkaGrafiki; }
protected String getCzasWykonania() { return czasWykonania; }
protected String getTrudnoscWykonania() { return trudnoscWykonania; }
protected String getSkladniki() { return skladniki; }
protected String getInstrukcje() { return instrukcje; }
}
| /**
* Klasa naleśników. Dziedziczy z Przepisu i nadpisuje wszystkie jego metody
*/ | import java.net.URL;
/**
* Klasa naleśników. Dziedziczy <SUF>*/
public class Nalesniki extends Przepis {
String tytul = "Naleśniki";
URL sciezkaGrafiki = Nalesniki.class.getResource("grafiki/nalesniki.jpg");
String czasWykonania = "Czas wykonania: 20 minut";
String trudnoscWykonania = "Trudność wykonania: łatwa";
String skladniki = "<html>Składniki:<br>" +
"250ml mąki pszennej<br>" +
"190ml wody (najlepiej gazowanej)<br>" +
"2 jajka<br>" +
"250ml mleka<br>" +
"szczypta soli<br>" +
"3 łyżki masła lub oleju roślinnego";
String instrukcje = "<html>Instrukcje:<br>" +
"1) Mąkę wsypać do miski, dodać jajka, mleko, wodę i sól.<br>" +
"2) Zmiksować na gładkie ciasto.<br>" +
"3) Dodać roztopione masło lub olej roślinny i razem zmiksować<br>" +
"(lub wykorzystać tłuszcz do smarowania patelni przed smażeniem<br>każdego naleśnika).<br>" +
"4) Naleśniki smażyć na dobrze rozgrzanej patelni z cienkim dnem np. naleśnikowej. " +
"Przewrócić na drugą stronę gdy spód naleśnika będzie już ładnie zrumieniony i ścięty.";
protected String getTytul() { return tytul; }
protected URL getSciezkaGrafiki() { return sciezkaGrafiki; }
protected String getCzasWykonania() { return czasWykonania; }
protected String getTrudnoscWykonania() { return trudnoscWykonania; }
protected String getSkladniki() { return skladniki; }
protected String getInstrukcje() { return instrukcje; }
}
| t |
5198_8 | NataliaLuberda/Object_oriented_programming-lab_2022-2023 | 1,552 | src/main/java/agh/ics/oop/GrassField.java | package agh.ics.oop;
import java.util.ArrayList;
import java.util.*;
import java.util.Random;
import java.lang.Math;
public class GrassField extends AbstractWorldMap implements IWorldMap,IPositionChangeObserver{
final int grassSample;
private final HashMap<Vector2d, IMapElement> grassSampleList = new HashMap<>();;
private final ArrayList<Vector2d> positionsOnTheField = new ArrayList<>();//wolne miejsca na mapie
private final MapBoundary listMap;
public GrassField(int grassSample){//konstruktor
this.listMap = new MapBoundary();
this.grassSample = grassSample;
for (int i = 0; i <= ((int) Math.sqrt(10 * grassSample)); i++){
for (int j = 0; j <= ((int) Math.sqrt(10 * grassSample)); j++){
positionsOnTheField.add(new Vector2d(i,j));//inicjowanie mapy
}
}
putGrass(positionsOnTheField);//metoda dodawania kępków trawy
}
public void putGrass(ArrayList<Vector2d> positionsOnTheField){//położenie trawy w losowych miejscach
Random randomSamplePlace = new Random();
int currentGrass = 0;
do {
int random = randomSamplePlace.nextInt(positionsOnTheField.size()-1);//losuje indeks
Vector2d grassPlace = positionsOnTheField.get(random);//wolne randomowe miejsce w zakresie tablicy
this.grassSampleList.put(grassPlace,new Grass(grassPlace));//dodaje twrawe do hashmapy
this.listMap.addEl(grassPlace);
positionsOnTheField.remove(grassPlace);//usuwam zajęte miejsce
currentGrass++;
} while (currentGrass<this.grassSample);
}
public HashMap<Vector2d, IMapElement> getGrass(){
return grassSampleList;//zwaracanie listy traw
};
@Override
public Vector2d getDownLeft() {
return this.listMap.downLeft();
}
@Override
public Vector2d getUppRight() {
return this.listMap.uppRight();
}
@Override
public boolean canMoveTo(Vector2d position){
Object object = this.objectAt(position);
return !(object instanceof Animal);//mogę się ruszyć jeśli nie jest zwierzakiem
}
@Override
public boolean place(Animal animal) {//kwestia położenia na mapie zwierzęcia
if (!isOccupied(animal.getPosition())) {//jeżeli nie zajęte to kładę
this.animals.put(animal.getPosition(),animal);
this.listMap.addEl(animal.getPosition());
animal.addObserver(this);
positionsOnTheField.remove(animal.getPosition());//usuwam zajęte miejsce
return true;
} else {
if (moveAnimalOnGrass(animal.getPosition())){//zwierzak zjada trawe a ta rośnie gdzie indziej
this.animals.put(animal.getPosition(),animal);//jeżeli tam była trawa to zwierzak ją zjadł i zostaje na jej miejscu
animal.addObserver(this);
return true;
}
}
throw new IllegalArgumentException(animal.getPosition() + " is not available position");
}
@Override
public Object objectAt(Vector2d position)
{
if(this.animals.get(position) != null) {
return this.animals.get(position);
} else if(this.grassSampleList.get(position) != null){
return this.grassSampleList.get(position);
}
return null;
}
public boolean moveAnimalOnGrass(Vector2d position){
Object ob = objectAt(position);//sprawdzam czy animal czy trawa czy null
if(ob instanceof Grass){//jeżeli trawa
Random randomSamplePlace = new Random();//losuje nowe miejsce dla trawy
int random = randomSamplePlace.nextInt(positionsOnTheField.size());
Vector2d grassPlace = positionsOnTheField.get(random);
this.grassSampleList.remove(((Grass) ob).getPosition());//usuwam poprzednią pozycję i trawę
this.grassSampleList.put(grassPlace,new Grass(grassPlace));//nowe miejsce dla trawy
this.listMap.addEl(grassPlace);
positionsOnTheField.remove(grassPlace);//usuwam je z dostępnych miejsc
return true;
}
return false;
}
@Override
public void positionChanged(Vector2d oldPosition, Vector2d newPosition) {
if (canMoveTo(newPosition)){
if(objectAt(newPosition) == null){//jeżeli niczego tam nie ma
IMapElement puszek = animals.get(oldPosition);
this.animals.remove(oldPosition);
this.animals.put(newPosition,puszek);//dodaje zwierze na innej pozycji
this.listMap.positionChanged(oldPosition,newPosition);
positionsOnTheField.add(oldPosition);//starą dodaje do dostepnych
positionsOnTheField.remove(newPosition);//nową odejmuje z dostępnych miejs
}
else {//jeżeli tam jest trawa
IMapElement puszek = animals.get(oldPosition);
this.animals.remove(oldPosition);
positionsOnTheField.add(oldPosition);//dodaje starą pozycje
this.listMap.removeEl(oldPosition);//nowej nie dodaje bo jest gdyż była na niej trawa
moveAnimalOnGrass(newPosition);//zmieniam pozycje zjedzonej trawy
this.animals.put(newPosition,puszek);
}
}
}
} | //kwestia położenia na mapie zwierzęcia | package agh.ics.oop;
import java.util.ArrayList;
import java.util.*;
import java.util.Random;
import java.lang.Math;
public class GrassField extends AbstractWorldMap implements IWorldMap,IPositionChangeObserver{
final int grassSample;
private final HashMap<Vector2d, IMapElement> grassSampleList = new HashMap<>();;
private final ArrayList<Vector2d> positionsOnTheField = new ArrayList<>();//wolne miejsca na mapie
private final MapBoundary listMap;
public GrassField(int grassSample){//konstruktor
this.listMap = new MapBoundary();
this.grassSample = grassSample;
for (int i = 0; i <= ((int) Math.sqrt(10 * grassSample)); i++){
for (int j = 0; j <= ((int) Math.sqrt(10 * grassSample)); j++){
positionsOnTheField.add(new Vector2d(i,j));//inicjowanie mapy
}
}
putGrass(positionsOnTheField);//metoda dodawania kępków trawy
}
public void putGrass(ArrayList<Vector2d> positionsOnTheField){//położenie trawy w losowych miejscach
Random randomSamplePlace = new Random();
int currentGrass = 0;
do {
int random = randomSamplePlace.nextInt(positionsOnTheField.size()-1);//losuje indeks
Vector2d grassPlace = positionsOnTheField.get(random);//wolne randomowe miejsce w zakresie tablicy
this.grassSampleList.put(grassPlace,new Grass(grassPlace));//dodaje twrawe do hashmapy
this.listMap.addEl(grassPlace);
positionsOnTheField.remove(grassPlace);//usuwam zajęte miejsce
currentGrass++;
} while (currentGrass<this.grassSample);
}
public HashMap<Vector2d, IMapElement> getGrass(){
return grassSampleList;//zwaracanie listy traw
};
@Override
public Vector2d getDownLeft() {
return this.listMap.downLeft();
}
@Override
public Vector2d getUppRight() {
return this.listMap.uppRight();
}
@Override
public boolean canMoveTo(Vector2d position){
Object object = this.objectAt(position);
return !(object instanceof Animal);//mogę się ruszyć jeśli nie jest zwierzakiem
}
@Override
public boolean place(Animal animal) {//kwestia położenia <SUF>
if (!isOccupied(animal.getPosition())) {//jeżeli nie zajęte to kładę
this.animals.put(animal.getPosition(),animal);
this.listMap.addEl(animal.getPosition());
animal.addObserver(this);
positionsOnTheField.remove(animal.getPosition());//usuwam zajęte miejsce
return true;
} else {
if (moveAnimalOnGrass(animal.getPosition())){//zwierzak zjada trawe a ta rośnie gdzie indziej
this.animals.put(animal.getPosition(),animal);//jeżeli tam była trawa to zwierzak ją zjadł i zostaje na jej miejscu
animal.addObserver(this);
return true;
}
}
throw new IllegalArgumentException(animal.getPosition() + " is not available position");
}
@Override
public Object objectAt(Vector2d position)
{
if(this.animals.get(position) != null) {
return this.animals.get(position);
} else if(this.grassSampleList.get(position) != null){
return this.grassSampleList.get(position);
}
return null;
}
public boolean moveAnimalOnGrass(Vector2d position){
Object ob = objectAt(position);//sprawdzam czy animal czy trawa czy null
if(ob instanceof Grass){//jeżeli trawa
Random randomSamplePlace = new Random();//losuje nowe miejsce dla trawy
int random = randomSamplePlace.nextInt(positionsOnTheField.size());
Vector2d grassPlace = positionsOnTheField.get(random);
this.grassSampleList.remove(((Grass) ob).getPosition());//usuwam poprzednią pozycję i trawę
this.grassSampleList.put(grassPlace,new Grass(grassPlace));//nowe miejsce dla trawy
this.listMap.addEl(grassPlace);
positionsOnTheField.remove(grassPlace);//usuwam je z dostępnych miejsc
return true;
}
return false;
}
@Override
public void positionChanged(Vector2d oldPosition, Vector2d newPosition) {
if (canMoveTo(newPosition)){
if(objectAt(newPosition) == null){//jeżeli niczego tam nie ma
IMapElement puszek = animals.get(oldPosition);
this.animals.remove(oldPosition);
this.animals.put(newPosition,puszek);//dodaje zwierze na innej pozycji
this.listMap.positionChanged(oldPosition,newPosition);
positionsOnTheField.add(oldPosition);//starą dodaje do dostepnych
positionsOnTheField.remove(newPosition);//nową odejmuje z dostępnych miejs
}
else {//jeżeli tam jest trawa
IMapElement puszek = animals.get(oldPosition);
this.animals.remove(oldPosition);
positionsOnTheField.add(oldPosition);//dodaje starą pozycje
this.listMap.removeEl(oldPosition);//nowej nie dodaje bo jest gdyż była na niej trawa
moveAnimalOnGrass(newPosition);//zmieniam pozycje zjedzonej trawy
this.animals.put(newPosition,puszek);
}
}
}
} | t |
3489_0 | Natka2001/Kopec_Wernik_Bak_Glodek | 1,331 | java_projekt1/src/Sala.java | import java.io.Serializable;
import java.util.ArrayList;
import java.util.Comparator;
enum EnumTypSali { wykladowa,
labolatoryjnaChemiczna,
labolatoryjnaFizyczna, komputerowa, cwiczeniowa }
/**
* Klasa zawiera podatwowe informacje o salach oraz dodaje rezerwacje
*/
public class Sala implements Comparable<Sala>, Serializable, IRezerwacja{
//Pola
private String numer;
private int iloscMiejsc;
private EnumTypSali typSali;
ArrayList<Rezerwacja> listaRezerwacji;
//setter
public void setNumer(String numer) {
this.numer = numer;
}
public void setIloscMiejsc(int iloscMiejsc) {
this.iloscMiejsc = iloscMiejsc;
}
public void setTypSali(EnumTypSali typSali) {
this.typSali = typSali;
}
public void setListaRezerwacji(ArrayList<Rezerwacja> listaRezerwacji) {
this.listaRezerwacji = listaRezerwacji;
}
//getter
public String getNumer() {
return numer;
}
public int getIloscMiejsc() {
return iloscMiejsc;
}
public EnumTypSali getTypSali() {
return typSali;
}
public ArrayList<Rezerwacja> getListaRezerwacji() {
return listaRezerwacji;
}
//konstruktory
public Sala() {
this.listaRezerwacji = new ArrayList<Rezerwacja>();
}
/**
* Główny konstruktor klasy Sala.
* @param numer
* @param iloscMiejsc
* @param typSali
*/
public Sala(String numer, int iloscMiejsc, EnumTypSali typSali) {
this.numer = numer;
this.iloscMiejsc = iloscMiejsc;
this.typSali = typSali;
this.listaRezerwacji = new ArrayList<Rezerwacja>();
}
/**
* Sprawdzenie czy istnieje już rezerwacja o takiej dacie.
* @param r
* @return
*/
public boolean CheckBooking(Rezerwacja r)
{
for(var item : listaRezerwacji)
{
if (item.getDay_start().getTime() == r.getDay_start().getTime())
{
if ((r.getStart_time().getTime() >= item.getStart_time().getTime() && r.getStart_time().getTime() < item.getEnd_time().getTime()))
{
return false;
}
else if (r.getEnd_time().getTime() > item.getStart_time().getTime() && r.getEnd_time().getTime() <= item.getEnd_time().getTime())
{
return false;
}
else if (r.getStart_time().getTime() < item.getStart_time().getTime() && r.getEnd_time().getTime() > item.getEnd_time().getTime())
{
return false;
}
}
}
return true;
}
/**
* Dodanie rezerwacji, stworzenie wyjątku gdy już istnieje rezerwacja w tym czasie
* @param r
* @throws WlasnyWyjatek
*/
public void DodajRezerwacje(Rezerwacja r) throws WlasnyWyjatek {
if(CheckBooking(r)){
listaRezerwacji.add(r);
}
else{
System.out.println("Wybrana rezerwacja już istnieje");
}
}
public void UsunRezerwacje(Rezerwacja r){
listaRezerwacji.remove(r);
}
/**
* Zwraca sformatowany string zawierający: numer, ilość miejsc, typ sali.
* @return
*/
@Override
public String toString() {
return "sala " + getTypSali() + ", numer sali: "+ getNumer() +
", iloscMiejsc: " + getIloscMiejsc();
}
//komparator
@Override
public int compareTo(Sala s) {
return Integer.compare(s.getIloscMiejsc(),this.getIloscMiejsc());
}
public static final class SalaKomparator implements Comparator<Sala> {
@Override
public int compare(Sala s1, Sala s2) {
return s1.getNumer().compareTo(s2.getNumer()); }
}
}
| /**
* Klasa zawiera podatwowe informacje o salach oraz dodaje rezerwacje
*/ | import java.io.Serializable;
import java.util.ArrayList;
import java.util.Comparator;
enum EnumTypSali { wykladowa,
labolatoryjnaChemiczna,
labolatoryjnaFizyczna, komputerowa, cwiczeniowa }
/**
* Klasa zawiera podatwowe <SUF>*/
public class Sala implements Comparable<Sala>, Serializable, IRezerwacja{
//Pola
private String numer;
private int iloscMiejsc;
private EnumTypSali typSali;
ArrayList<Rezerwacja> listaRezerwacji;
//setter
public void setNumer(String numer) {
this.numer = numer;
}
public void setIloscMiejsc(int iloscMiejsc) {
this.iloscMiejsc = iloscMiejsc;
}
public void setTypSali(EnumTypSali typSali) {
this.typSali = typSali;
}
public void setListaRezerwacji(ArrayList<Rezerwacja> listaRezerwacji) {
this.listaRezerwacji = listaRezerwacji;
}
//getter
public String getNumer() {
return numer;
}
public int getIloscMiejsc() {
return iloscMiejsc;
}
public EnumTypSali getTypSali() {
return typSali;
}
public ArrayList<Rezerwacja> getListaRezerwacji() {
return listaRezerwacji;
}
//konstruktory
public Sala() {
this.listaRezerwacji = new ArrayList<Rezerwacja>();
}
/**
* Główny konstruktor klasy Sala.
* @param numer
* @param iloscMiejsc
* @param typSali
*/
public Sala(String numer, int iloscMiejsc, EnumTypSali typSali) {
this.numer = numer;
this.iloscMiejsc = iloscMiejsc;
this.typSali = typSali;
this.listaRezerwacji = new ArrayList<Rezerwacja>();
}
/**
* Sprawdzenie czy istnieje już rezerwacja o takiej dacie.
* @param r
* @return
*/
public boolean CheckBooking(Rezerwacja r)
{
for(var item : listaRezerwacji)
{
if (item.getDay_start().getTime() == r.getDay_start().getTime())
{
if ((r.getStart_time().getTime() >= item.getStart_time().getTime() && r.getStart_time().getTime() < item.getEnd_time().getTime()))
{
return false;
}
else if (r.getEnd_time().getTime() > item.getStart_time().getTime() && r.getEnd_time().getTime() <= item.getEnd_time().getTime())
{
return false;
}
else if (r.getStart_time().getTime() < item.getStart_time().getTime() && r.getEnd_time().getTime() > item.getEnd_time().getTime())
{
return false;
}
}
}
return true;
}
/**
* Dodanie rezerwacji, stworzenie wyjątku gdy już istnieje rezerwacja w tym czasie
* @param r
* @throws WlasnyWyjatek
*/
public void DodajRezerwacje(Rezerwacja r) throws WlasnyWyjatek {
if(CheckBooking(r)){
listaRezerwacji.add(r);
}
else{
System.out.println("Wybrana rezerwacja już istnieje");
}
}
public void UsunRezerwacje(Rezerwacja r){
listaRezerwacji.remove(r);
}
/**
* Zwraca sformatowany string zawierający: numer, ilość miejsc, typ sali.
* @return
*/
@Override
public String toString() {
return "sala " + getTypSali() + ", numer sali: "+ getNumer() +
", iloscMiejsc: " + getIloscMiejsc();
}
//komparator
@Override
public int compareTo(Sala s) {
return Integer.compare(s.getIloscMiejsc(),this.getIloscMiejsc());
}
public static final class SalaKomparator implements Comparator<Sala> {
@Override
public int compare(Sala s1, Sala s2) {
return s1.getNumer().compareTo(s2.getNumer()); }
}
}
| t |
6078_0 | Nekio21/Nauka-Slowek | 1,531 | src/main/java/umk/mat/jakuburb/controllers/ResultatController.java | package umk.mat.jakuburb.controllers;
import javafx.fxml.FXML;
import javafx.scene.control.Label;
import javafx.scene.input.MouseEvent;
import org.hibernate.Session;
import org.hibernate.query.Query;
import umk.mat.jakuburb.controllers.helpers.MyController;
import umk.mat.jakuburb.database.MyDatabase;
import umk.mat.jakuburb.database.MyDatabaseBox;
import umk.mat.jakuburb.database.MyDatabaseInterface;
import umk.mat.jakuburb.encje.Gra;
import umk.mat.jakuburb.encje.SlowkaGra;
import umk.mat.jakuburb.encje.User;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import java.util.function.BinaryOperator;
import static umk.mat.jakuburb.controllers.PlayController.GRA;
public class ResultatController extends MyController implements MyDatabaseInterface {
@FXML
private Label gratulacjeOpis;
@FXML
private Label gratulacje;
private int procent;
private int dobre;
private int zle;
//TODO: STowrzyc klase z trybami gry :>
//private TrybGry trybGry;
private Gra gra;
private String text;
private Random random;
private User user;
private String[] beggin = new String[]{
"Super, że kolejny raz ćwiczysz z naszym programem :) ",
"Nawet nie wiesz jakie przysługe robisz swojemu mózgowi na przyszłość !!! ",
"Kolejny krok za tobą, jesteś jak Amstron na księżycu, stawiasz krok za krokiem ku lepszej przyszłości BRAWO ",
"Dobrze, że kolejny raz możemy się spotkać przy podsumowaniu. ",
"Nawet jesli Ci się nie wydaje to naprawde robisz olbrzymie postepy!!!! "
};
private String[] end = new String[]{
"Trzymaj tak dalej i pamietaj, że wielki sukces to zasługa małych kroków :) ",
"Każdą próbe udana, mniej lub bardziej, zliżasz się do zywyciestwa ",
"Widzimy się na kolejny tescie ;) ",
"Tak trzymaj, widzimy się niedlugo... ",
"Robisz duże postepy, trzymaj tak dalej :) "
};
private String[] startTalkingAboutData = new String[]{
"Pozwól mi powiedzieć troszeczke o danych... ",
"A teraz przejdzmy do szczegółów twojej rozgrywki ",
"Jesli chodzi o twarde dane ",
"Warto powiedzieć, że ",
"A teraz przyjżyjmy się bliżej danymi... "
};
@FXML
public void initialize(){
super.initialize();
gra = (Gra)dataSender.get(GRA);
user = (User)dataSender.get(LoginController.PW_KEY_ID);
random = new Random();
myDatabase = MyDatabase.createDatabase();
myDatabase.makeSession(this);
}
private String information(Gra gra){
int ilosc = gra.getSlowkaGraList().size();
int dobrych = 0;
int zlych = 0;
int punkty = 0;
String data = gra.getDataGry().toString();
String info = gra.getGameMode().toString();
for(SlowkaGra sg: gra.getSlowkaGraList()){
if(sg.getDobrzeCzyZle()){
dobrych++;
} else{
zlych++;
}
punkty += sg.getSlowka().getPunkty();
}
String text = "";
text += startTalkingAboutData[random.nextInt(5)];
text += "Ilość słowek, która brała udział w tescie to " + ilosc + ". ";
text += "Dobrych odpowiedzi było " + dobrych + ", natomiast złych " + zlych + ". ";
text += "Grałeś w trybie " + info + ". ";
text += "A gre zaczołes " + data + ". ";
text += "Dzisiejszy wysiłek sprawił, że z słowek, które dzisiaj przerabiałeś masz łacznie " + punkty + " BRAWO. ";
return text;
}
@FXML
public void returnMethod(MouseEvent mouseEvent){
dataSender.add(null, GRA);
change("zestawy.fxml", mouseEvent);
}
@Override
public Object inside(MyDatabaseBox myDatabaseBox, Session session) {
Query<SlowkaGra> query = session.createQuery("SELECT g.slowkaGraList FROM Gra g WHERE g.idGra = :id", SlowkaGra.class);
query.setParameter("id", gra.getIdGra());
List<SlowkaGra> sg = query.getResultList();
if(sg != null) {
gra.setSlowkaGraList(sg);
}
return sg;
}
@Override
public void after(MyDatabaseBox myDatabaseBox, Object wynik) {
text = beggin[random.nextInt(5)] + information(gra) + end[random.nextInt(5)];
gratulacjeOpis.setText(text);
gratulacje.setText("Gratulacje " + user.getLogin());
}
}
| //TODO: STowrzyc klase z trybami gry :> | package umk.mat.jakuburb.controllers;
import javafx.fxml.FXML;
import javafx.scene.control.Label;
import javafx.scene.input.MouseEvent;
import org.hibernate.Session;
import org.hibernate.query.Query;
import umk.mat.jakuburb.controllers.helpers.MyController;
import umk.mat.jakuburb.database.MyDatabase;
import umk.mat.jakuburb.database.MyDatabaseBox;
import umk.mat.jakuburb.database.MyDatabaseInterface;
import umk.mat.jakuburb.encje.Gra;
import umk.mat.jakuburb.encje.SlowkaGra;
import umk.mat.jakuburb.encje.User;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import java.util.function.BinaryOperator;
import static umk.mat.jakuburb.controllers.PlayController.GRA;
public class ResultatController extends MyController implements MyDatabaseInterface {
@FXML
private Label gratulacjeOpis;
@FXML
private Label gratulacje;
private int procent;
private int dobre;
private int zle;
//TODO: STowrzyc <SUF>
//private TrybGry trybGry;
private Gra gra;
private String text;
private Random random;
private User user;
private String[] beggin = new String[]{
"Super, że kolejny raz ćwiczysz z naszym programem :) ",
"Nawet nie wiesz jakie przysługe robisz swojemu mózgowi na przyszłość !!! ",
"Kolejny krok za tobą, jesteś jak Amstron na księżycu, stawiasz krok za krokiem ku lepszej przyszłości BRAWO ",
"Dobrze, że kolejny raz możemy się spotkać przy podsumowaniu. ",
"Nawet jesli Ci się nie wydaje to naprawde robisz olbrzymie postepy!!!! "
};
private String[] end = new String[]{
"Trzymaj tak dalej i pamietaj, że wielki sukces to zasługa małych kroków :) ",
"Każdą próbe udana, mniej lub bardziej, zliżasz się do zywyciestwa ",
"Widzimy się na kolejny tescie ;) ",
"Tak trzymaj, widzimy się niedlugo... ",
"Robisz duże postepy, trzymaj tak dalej :) "
};
private String[] startTalkingAboutData = new String[]{
"Pozwól mi powiedzieć troszeczke o danych... ",
"A teraz przejdzmy do szczegółów twojej rozgrywki ",
"Jesli chodzi o twarde dane ",
"Warto powiedzieć, że ",
"A teraz przyjżyjmy się bliżej danymi... "
};
@FXML
public void initialize(){
super.initialize();
gra = (Gra)dataSender.get(GRA);
user = (User)dataSender.get(LoginController.PW_KEY_ID);
random = new Random();
myDatabase = MyDatabase.createDatabase();
myDatabase.makeSession(this);
}
private String information(Gra gra){
int ilosc = gra.getSlowkaGraList().size();
int dobrych = 0;
int zlych = 0;
int punkty = 0;
String data = gra.getDataGry().toString();
String info = gra.getGameMode().toString();
for(SlowkaGra sg: gra.getSlowkaGraList()){
if(sg.getDobrzeCzyZle()){
dobrych++;
} else{
zlych++;
}
punkty += sg.getSlowka().getPunkty();
}
String text = "";
text += startTalkingAboutData[random.nextInt(5)];
text += "Ilość słowek, która brała udział w tescie to " + ilosc + ". ";
text += "Dobrych odpowiedzi było " + dobrych + ", natomiast złych " + zlych + ". ";
text += "Grałeś w trybie " + info + ". ";
text += "A gre zaczołes " + data + ". ";
text += "Dzisiejszy wysiłek sprawił, że z słowek, które dzisiaj przerabiałeś masz łacznie " + punkty + " BRAWO. ";
return text;
}
@FXML
public void returnMethod(MouseEvent mouseEvent){
dataSender.add(null, GRA);
change("zestawy.fxml", mouseEvent);
}
@Override
public Object inside(MyDatabaseBox myDatabaseBox, Session session) {
Query<SlowkaGra> query = session.createQuery("SELECT g.slowkaGraList FROM Gra g WHERE g.idGra = :id", SlowkaGra.class);
query.setParameter("id", gra.getIdGra());
List<SlowkaGra> sg = query.getResultList();
if(sg != null) {
gra.setSlowkaGraList(sg);
}
return sg;
}
@Override
public void after(MyDatabaseBox myDatabaseBox, Object wynik) {
text = beggin[random.nextInt(5)] + information(gra) + end[random.nextInt(5)];
gratulacjeOpis.setText(text);
gratulacje.setText("Gratulacje " + user.getLogin());
}
}
| t |
6241_0 | Olamon/pizzaFAP | 671 | application/pizzaProject/src/objects/Account.java | /*
* klasa odzwierciedlająca pojedynczego uzytkownika
* zmieniłem jej nazwę, bo był konflikt między użytkownikiem - użytkownikiem
* aplikacji, a użytkownikiem - osobie o uprawnieniach użytkownika
*/
/*
* Zmieniłem tę klasę na klasę będącą pojemnikiem na wartości pojedyńczej krotki
* z danej tabeli, a metody dotyczące bazy przeniosłem do paczki "database"
*/
package objects;
import java.sql.ResultSet;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Account implements DatabaseObject<Account> {
public String email;
public String password;
public String typ_konta;
public Account(String email, String password, String typ_konta) {
this.email = new String(email);
this.password = new String(password);
this.typ_konta = new String(typ_konta);
}
public static Account converter = new Account("", "", "");
public Vector<Account> convert(ResultSet rs) {
Vector<Account> result = new Vector<Account>();
try {
while(rs.next()) {
result.add(new Account(rs.getString("email"),
rs.getString("pass"),
rs.getString("typ_konta")));
}
}
catch (Exception ex) {
Logger lgr = Logger.getLogger(Account.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
return result;
}
/*
//zwraca listę wszystkich uzytkownikow w bazie danych
public static List<Account> GetAll() throws SQLException
{
return GetAll(Session.current().getTable("uzytkownik").select(null));
}
//zwraca listę wszystkich ocen użytkownika
public List<Ocena> GetUserReviews() throws SQLException
{
ResultSet rs = Session.current().selectQuery(null, "ocena", "email = " + email);
if (rs != null)
return Ocena.GetAll(rs);
else return null;
}
*/
}
| /*
* klasa odzwierciedlająca pojedynczego uzytkownika
* zmieniłem jej nazwę, bo był konflikt między użytkownikiem - użytkownikiem
* aplikacji, a użytkownikiem - osobie o uprawnieniach użytkownika
*/ | /*
* klasa odzwierciedlająca pojedynczego <SUF>*/
/*
* Zmieniłem tę klasę na klasę będącą pojemnikiem na wartości pojedyńczej krotki
* z danej tabeli, a metody dotyczące bazy przeniosłem do paczki "database"
*/
package objects;
import java.sql.ResultSet;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Account implements DatabaseObject<Account> {
public String email;
public String password;
public String typ_konta;
public Account(String email, String password, String typ_konta) {
this.email = new String(email);
this.password = new String(password);
this.typ_konta = new String(typ_konta);
}
public static Account converter = new Account("", "", "");
public Vector<Account> convert(ResultSet rs) {
Vector<Account> result = new Vector<Account>();
try {
while(rs.next()) {
result.add(new Account(rs.getString("email"),
rs.getString("pass"),
rs.getString("typ_konta")));
}
}
catch (Exception ex) {
Logger lgr = Logger.getLogger(Account.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
return result;
}
/*
//zwraca listę wszystkich uzytkownikow w bazie danych
public static List<Account> GetAll() throws SQLException
{
return GetAll(Session.current().getTable("uzytkownik").select(null));
}
//zwraca listę wszystkich ocen użytkownika
public List<Ocena> GetUserReviews() throws SQLException
{
ResultSet rs = Session.current().selectQuery(null, "ocena", "email = " + email);
if (rs != null)
return Ocena.GetAll(rs);
else return null;
}
*/
}
| t |
10598_2 | Oskarovsky/Chater | 134 | ChaterClient/src/MessageListener.java | // interfejs do odbierania wiadomości (tworzenie listenera)
public interface MessageListener {
// zawsze, gdy ktoś wyślę wiadomosć (np. gdy user wysyła wiadomość do serwera, a serwer przekazuje ją do innego usera)
// fromLogin - od kogo przychodzi ja wiadomość, msgBody - jaka jest treść wiadomości
public void onMessage(String fromLogin, String msgBody);
}
| // fromLogin - od kogo przychodzi ja wiadomość, msgBody - jaka jest treść wiadomości | // interfejs do odbierania wiadomości (tworzenie listenera)
public interface MessageListener {
// zawsze, gdy ktoś wyślę wiadomosć (np. gdy user wysyła wiadomość do serwera, a serwer przekazuje ją do innego usera)
// fromLogin - <SUF>
public void onMessage(String fromLogin, String msgBody);
}
| t |
6598_12 | OsmanMR99/Programming-Java | 2,763 | Projects/Tic_tac/Board.java | import java.util.Scanner;
import java.io.IOException;
import java.util.InputMismatchException;
public class Board {
private char[] cells = new char[9]; //stan planszy
private Scanner scanner = new Scanner(System.in);
private AI ai = new AI(this); //Obiekt AI
private boolean aiErrors = false; //jak true to błędy
private boolean twoPlayers = false; //jak true to 2 graczy
private Player player1;
private Player player2;
private File file; //dla pliku do zapisu
public Board() throws IOException {
for (int i = 0; i < 9; i++) {
cells[i] = (char) (i + '1'); //rzutowanie z całkowitych na znaki
}
file = new File("game_results.txt"); //obiekt jako plik
}
public boolean startGame() throws IOException {
// Wybór trybu gry
System.out.println("Wybierz tryb gry: 1 - gracz vs AI, 2 - gracz vs gracz, 3 - gracz vs AI (AI popełnia błędy), Q - quit");
String mode = scanner.next();
if (mode.equalsIgnoreCase("Q")) { //czy małe czy duże q i tak wyłączy
file.close();
return false;
}
int modeInt = Integer.parseInt(mode); // Konwersja wyboru na liczbę
System.out.println("Podaj imię gracza 1:");
String name = scanner.next();
player1 = new Player(name); //obiekt player1
file.write("ID: " + player1.getId() + ", Imię: " + player1.getName() + "\n"); //info do pliku
if (modeInt == 2) {//od dwóch graczy
twoPlayers = true;
System.out.println("Podaj imię gracza 2:");
name = scanner.next();
player2 = new Player(name); // Tworzenie gracza 2
file.write("ID: " + player2.getId() + ", Imię: " + player2.getName() + "\n");
} else if (modeInt == 3) {
aiErrors = true; // zeby IA z błedami
}
printBoard(); //rysowanie
System.out.println("Kto zaczyna? 1 - gracz, 2 - komputer");
int choice = scanner.nextInt();
if (choice == 1) {
playerMove(); //jak gracz jest pierwszy a nie to PC
} else {
aiMove();
}
return true;
}
public void playerMove() throws IOException {
System.out.println("Podaj numer pola (1-9):");
while (true) {
try {
int move = scanner.nextInt() - 1; //-1 bo w tablicy od 0
if (move >= 0 && move < 9 && cells[move] == (char) (move + '1')) {//jak dostępne
cells[move] = 'X'; //przesłanie gdzie ruch
printBoard(); // Wyświetlanie
if (checkWin('X')) {
System.out.println("\033[0;32m" + "Gracz wygrywa!" + "\033[0m");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: Komputer " + "\nWygrał Player 1\n");
file.close(); // Zamykanie pliku
} else if (isDraw()) { // Sprawdzanie czy jest remis
System.out.println("Remis!");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: Komputer " + "Remis\n");
file.close(); // jak remis to close
} else if (twoPlayers) { // tylko jak 2 graczy
secondPlayerMove();
} else { // z komputerem
aiMove();
}
break;
} else {
System.out.println("To pole jest już zajęte lub nie istnieje. Spróbuj ponownie.");
}
} catch (InputMismatchException e) {
System.out.println("Nieprawidłowe dane wejściowe. Wprowadź liczbę od 1 do 9.");
scanner.next(); //zabezpieczenie jakby nie było od 1-9
}
}
}
public void secondPlayerMove() throws IOException {
System.out.println("Drugi gracz - podaj numer pola (1-9):");
while (true) {
try {
int move = scanner.nextInt() - 1; //info z ruchu 2 player
if (move >= 0 && move < 9 && cells[move] == (char) (move + '1')) {
cells[move] = 'O';
printBoard();
if (checkWin('O')) {
System.out.println("\033[0;32m" + "Drugi gracz wygrywa!" + "\033[0m");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: " + player2.getName() + "(ID: " + player2.getId() + ") " + "\nWygrał Player 2\n");
file.close();
} else if (isDraw()) {
System.out.println("Remis!");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: " + player2.getName() + "(ID: " + player2.getId() + ") " + "Remis\n");
file.close();
} else {
playerMove();
}
break;
} else {
System.out.println("To pole jest już zajęte lub nie istnieje. Spróbuj ponownie.");
}
} catch (InputMismatchException e) {
System.out.println("Nieprawidłowe dane wejściowe. Wprowadź liczbę od 1 do 9.");
scanner.next();
}
}
}
public void aiMove() throws IOException {
int move = ai.getMove(aiErrors);
cells[move] = 'O';
printBoard();
if (checkWin('O')) {
System.out.println("\033[0;31m" + "Komputer wygrywa!" + "\033[0m");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: Komputer " + "Wygrał Player 2\n");
file.close();
} else if (isDraw()) {
System.out.println("Remis!");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: Komputer " + "Remis\n");
file.close();
} else {
playerMove();
}
}
public void printBoard() {
for (int i = 0; i < 9; i++) {
if (i % 3 == 0) {
System.out.println();
}
if (cells[i] == 'X') {
System.out.print("\033[0;34m" + cells[i] + " " + "\033[0m");
} else if (cells[i] == 'O') {
System.out.print("\033[0;33m" + cells[i] + " " + "\033[0m");
} else {
System.out.print(cells[i] + " ");
}
}
System.out.println();
}
public boolean checkWin(char player) {
for (int i = 0; i < 9; i += 3) {
if (cells[i] == player && cells[i + 1] == player && cells[i + 2] == player) {
return true; //w poziomie
}
}
for (int i = 0; i < 3; i++) {
if (cells[i] == player && cells[i + 3] == player && cells[i + 6] == player) {
return true; //w pionie
}
}
//na przekątnych
if (cells[0] == player && cells[4] == player && cells[8] == player) {
return true;
}
if (cells[2] == player && cells[4] == player && cells[6] == player) {
return true;
}
return false; //brak
}
public boolean isDraw() {
//czy remis
for (int i = 0; i < 9; i++) {
if (cells[i] == (char) (i + '1')) {
return false; // jak cos puste to nie ma remisu
}
}
return true; // tylko jak wszystko pełne
}
public char[] getCells() {
return cells; //to daje tabilce z stanem planszy
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();//łańcuch z planszy
for (int i = 0; i < 9; i++) {
if (i % 3 == 0) {
sb.append("\n");//dołącza do konca
}
if (cells[i] == 'X') {
sb.append("\033[0;34m" + cells[i] + " " + "\033[0m");
} else if (cells[i] == 'O') {
sb.append("\033[0;33m" + cells[i] + " " + "\033[0m");
} else {
sb.append(cells[i] + " ");
}
}
sb.append("\n");
return sb.toString();
}
}
| //jak gracz jest pierwszy a nie to PC
| import java.util.Scanner;
import java.io.IOException;
import java.util.InputMismatchException;
public class Board {
private char[] cells = new char[9]; //stan planszy
private Scanner scanner = new Scanner(System.in);
private AI ai = new AI(this); //Obiekt AI
private boolean aiErrors = false; //jak true to błędy
private boolean twoPlayers = false; //jak true to 2 graczy
private Player player1;
private Player player2;
private File file; //dla pliku do zapisu
public Board() throws IOException {
for (int i = 0; i < 9; i++) {
cells[i] = (char) (i + '1'); //rzutowanie z całkowitych na znaki
}
file = new File("game_results.txt"); //obiekt jako plik
}
public boolean startGame() throws IOException {
// Wybór trybu gry
System.out.println("Wybierz tryb gry: 1 - gracz vs AI, 2 - gracz vs gracz, 3 - gracz vs AI (AI popełnia błędy), Q - quit");
String mode = scanner.next();
if (mode.equalsIgnoreCase("Q")) { //czy małe czy duże q i tak wyłączy
file.close();
return false;
}
int modeInt = Integer.parseInt(mode); // Konwersja wyboru na liczbę
System.out.println("Podaj imię gracza 1:");
String name = scanner.next();
player1 = new Player(name); //obiekt player1
file.write("ID: " + player1.getId() + ", Imię: " + player1.getName() + "\n"); //info do pliku
if (modeInt == 2) {//od dwóch graczy
twoPlayers = true;
System.out.println("Podaj imię gracza 2:");
name = scanner.next();
player2 = new Player(name); // Tworzenie gracza 2
file.write("ID: " + player2.getId() + ", Imię: " + player2.getName() + "\n");
} else if (modeInt == 3) {
aiErrors = true; // zeby IA z błedami
}
printBoard(); //rysowanie
System.out.println("Kto zaczyna? 1 - gracz, 2 - komputer");
int choice = scanner.nextInt();
if (choice == 1) {
playerMove(); //jak gracz <SUF>
} else {
aiMove();
}
return true;
}
public void playerMove() throws IOException {
System.out.println("Podaj numer pola (1-9):");
while (true) {
try {
int move = scanner.nextInt() - 1; //-1 bo w tablicy od 0
if (move >= 0 && move < 9 && cells[move] == (char) (move + '1')) {//jak dostępne
cells[move] = 'X'; //przesłanie gdzie ruch
printBoard(); // Wyświetlanie
if (checkWin('X')) {
System.out.println("\033[0;32m" + "Gracz wygrywa!" + "\033[0m");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: Komputer " + "\nWygrał Player 1\n");
file.close(); // Zamykanie pliku
} else if (isDraw()) { // Sprawdzanie czy jest remis
System.out.println("Remis!");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: Komputer " + "Remis\n");
file.close(); // jak remis to close
} else if (twoPlayers) { // tylko jak 2 graczy
secondPlayerMove();
} else { // z komputerem
aiMove();
}
break;
} else {
System.out.println("To pole jest już zajęte lub nie istnieje. Spróbuj ponownie.");
}
} catch (InputMismatchException e) {
System.out.println("Nieprawidłowe dane wejściowe. Wprowadź liczbę od 1 do 9.");
scanner.next(); //zabezpieczenie jakby nie było od 1-9
}
}
}
public void secondPlayerMove() throws IOException {
System.out.println("Drugi gracz - podaj numer pola (1-9):");
while (true) {
try {
int move = scanner.nextInt() - 1; //info z ruchu 2 player
if (move >= 0 && move < 9 && cells[move] == (char) (move + '1')) {
cells[move] = 'O';
printBoard();
if (checkWin('O')) {
System.out.println("\033[0;32m" + "Drugi gracz wygrywa!" + "\033[0m");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: " + player2.getName() + "(ID: " + player2.getId() + ") " + "\nWygrał Player 2\n");
file.close();
} else if (isDraw()) {
System.out.println("Remis!");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: " + player2.getName() + "(ID: " + player2.getId() + ") " + "Remis\n");
file.close();
} else {
playerMove();
}
break;
} else {
System.out.println("To pole jest już zajęte lub nie istnieje. Spróbuj ponownie.");
}
} catch (InputMismatchException e) {
System.out.println("Nieprawidłowe dane wejściowe. Wprowadź liczbę od 1 do 9.");
scanner.next();
}
}
}
public void aiMove() throws IOException {
int move = ai.getMove(aiErrors);
cells[move] = 'O';
printBoard();
if (checkWin('O')) {
System.out.println("\033[0;31m" + "Komputer wygrywa!" + "\033[0m");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: Komputer " + "Wygrał Player 2\n");
file.close();
} else if (isDraw()) {
System.out.println("Remis!");
file.write("Player1: " + player1.getName() + "(ID: " + player1.getId() + ") " + "Player2: Komputer " + "Remis\n");
file.close();
} else {
playerMove();
}
}
public void printBoard() {
for (int i = 0; i < 9; i++) {
if (i % 3 == 0) {
System.out.println();
}
if (cells[i] == 'X') {
System.out.print("\033[0;34m" + cells[i] + " " + "\033[0m");
} else if (cells[i] == 'O') {
System.out.print("\033[0;33m" + cells[i] + " " + "\033[0m");
} else {
System.out.print(cells[i] + " ");
}
}
System.out.println();
}
public boolean checkWin(char player) {
for (int i = 0; i < 9; i += 3) {
if (cells[i] == player && cells[i + 1] == player && cells[i + 2] == player) {
return true; //w poziomie
}
}
for (int i = 0; i < 3; i++) {
if (cells[i] == player && cells[i + 3] == player && cells[i + 6] == player) {
return true; //w pionie
}
}
//na przekątnych
if (cells[0] == player && cells[4] == player && cells[8] == player) {
return true;
}
if (cells[2] == player && cells[4] == player && cells[6] == player) {
return true;
}
return false; //brak
}
public boolean isDraw() {
//czy remis
for (int i = 0; i < 9; i++) {
if (cells[i] == (char) (i + '1')) {
return false; // jak cos puste to nie ma remisu
}
}
return true; // tylko jak wszystko pełne
}
public char[] getCells() {
return cells; //to daje tabilce z stanem planszy
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();//łańcuch z planszy
for (int i = 0; i < 9; i++) {
if (i % 3 == 0) {
sb.append("\n");//dołącza do konca
}
if (cells[i] == 'X') {
sb.append("\033[0;34m" + cells[i] + " " + "\033[0m");
} else if (cells[i] == 'O') {
sb.append("\033[0;33m" + cells[i] + " " + "\033[0m");
} else {
sb.append(cells[i] + " ");
}
}
sb.append("\n");
return sb.toString();
}
}
| t |
5685_0 | PJONTAZ99/ZadaniazJAVASDA | 391 | src/main/java/Zadanie7.java | import java.util.Scanner;
public class Zadanie7 {
/*
Napisz program, który pobiera imie od użytkownika, najpierw jednak wypisze na ekran słowa "Podaj swoje imie".
Imię powinno zostać wydrukowane na ekran.
Jeśli podane imię zgadza się z "John Wick",
to na ekran program powinien wypisać "Widzę, że znów pracujesz John",
w przeciwnym przypadku program powinien wydrukować na ekran "Witaj, [xyz]",
gdzie [xyz], powinno zostać zastąpione wartością podaną przez użytkownika.
*/
public static void main(String[] args) {
String specialName = "John Wick";//specjalne imie
System.out.println("Podaj swoje imie");
Scanner scanner = new Scanner(System.in);
String imie = scanner.nextLine();//pobranie od użytkownika
System.out.println("Twoje imię to "+ imie);
if (specialName.contains(imie))//Warunek sprawdza czy imie zawiera się w specjanym imieniu
{
System.out.println("Widzę, że znów pracujesz John");
}
else {
System.out.println("Witaj, "+ imie);
}
}
}
| /*
Napisz program, który pobiera imie od użytkownika, najpierw jednak wypisze na ekran słowa "Podaj swoje imie".
Imię powinno zostać wydrukowane na ekran.
Jeśli podane imię zgadza się z "John Wick",
to na ekran program powinien wypisać "Widzę, że znów pracujesz John",
w przeciwnym przypadku program powinien wydrukować na ekran "Witaj, [xyz]",
gdzie [xyz], powinno zostać zastąpione wartością podaną przez użytkownika.
*/ | import java.util.Scanner;
public class Zadanie7 {
/*
Napisz program, który <SUF>*/
public static void main(String[] args) {
String specialName = "John Wick";//specjalne imie
System.out.println("Podaj swoje imie");
Scanner scanner = new Scanner(System.in);
String imie = scanner.nextLine();//pobranie od użytkownika
System.out.println("Twoje imię to "+ imie);
if (specialName.contains(imie))//Warunek sprawdza czy imie zawiera się w specjanym imieniu
{
System.out.println("Widzę, że znów pracujesz John");
}
else {
System.out.println("Witaj, "+ imie);
}
}
}
| t |
9059_3 | PMerdala/algorithms4 | 1,435 | src/main/java/pl/pmerdala/algs4/std/StdRandom.java | package pl.pmerdala.algs4.std;
import java.util.Random;
public class StdRandom {
private Random random = new Random();
/**
* ustawnienie ziarna pzowala na generowanie zawsze takich samych danych wejściowych
*
* @param seed
*/
public void setSeed(long seed) {
random = new Random(seed);
}
/**
* Generowanie liczby pseudolosowej rzeczywistej z przedziału [0,1)
*
* @return
*/
public double random() {
return random.nextDouble();
}
/**
* Generowanie liczby pseudolosowej rzeczywistej z przedziału [0,1)
*
* @return
*/
public double uniform() {
return random.nextDouble();
}
/**
* Generownaie liczby pseudolosowej całkowitej z przediału [0,(n-1)]
*
* @param n
* @return
*/
public int uniform(int n) {
return random.nextInt(n);
}
/**
* Generownaie liczby pseudolosowej całkowitej z przediału [lo, (hi-1)]
*
* @param lo - najmniejsza wartość, hi - największa wartość
* @return
*/
public int uniform(int lo, int hi) {
return lo + uniform(hi - lo);
}
/**
* Generownaie liczby pseudolosowej reczywistej z przediału [lo - hi)
*
* @param lo, hi
* @return
*/
public double uniform(double lo, double hi) {
return lo + random() * (hi - lo);
}
/**
* Zwraca true z prawdopodobieństwem p
*
* @param p - prawdopodobieństo
* @return
*/
public boolean bernoulli(double p) {
return uniform() < p;
}
/**
* Zwraca true z prawdopodobieństwem 50%
*
* @return
*/
public boolean bernoulli() {
return bernoulli(.5);
}
/**
* Generowanie zmiennych losowych o Rozkładzie normalnym, średnia 0, odch. st. 1
*
* @return
*/
public double gaussian() {
double r, x, y;
do {
x = uniform(-1.0, 1.0);
y = uniform(-1.0, 1.0);
r = x * x + y * y;
} while (r >= 1 || r == 0);
return x * Math.sqrt(-2 * Math.log(r) / r);
}
/**
* Rozkład normalny, średnia m, odch. st. s
*
* @return
*/
public double gaussian(double mean, double stddev) {
return mean + stddev * gaussian();
}
/**
* Generowanie zmiennej całkowitej o rozkładzie geometrycznym ze średnią(mean) 1/p
* użyto algorytmu Knuth
*
* @param p
* @return
*/
public int geometric(double p) {
return (int) Math.ceil(Math.log(uniform()) / Math.log(1.0 - p));
}
/**
* Generowanie zmiennej całkowitej o rozkłądznie Poissona ze średnią (mean) lambda.
* uzyto algorytmu Knuth
*
* @param lambda
* @return
* @see "http://en.wikipedia.org/wiki/Poisson_distribution"
*/
public int poisson(double lambda) {
int k = 0;
double p = 1.0;
double L = Math.exp(-lambda);
do {
k++;
p *= uniform();
} while (p >= L);
return k - 1;
}
/**
* Generowanie zmiennej rzeczywistej o rozkładzie pareto z parametrem podziału alpha
*
* @param alpha
* @return
*/
public double pareto(double alpha) {
return Math.pow(1 - uniform(), -1.0 / alpha) - 1.0;
}
/**
* Generowanie zmiennej rzeczywistej o rozkładzie cauchy
* @return
*/
public double cauchy(){
return Math.tan(Math.PI*(uniform()-.5));
}
/**
* Zwraca i z prawdopodobieństwem a[i]
*
* @param a tabela z wartościami rzeczyistymi z [rzedziału [0,1)
* @return
*/
public int discrete(double[] a) {
double r = uniform();
double sum = 0.0;
for (int i = 0; i < a.length; i++) {
sum += a[i];
if(sum>=r) return i;
}
assert(false);
return -1;
}
/**
* Losowo porządkuje elementy tablicy a[]
*
* @param a
*/
public void shuffle(double[] a) {
}
}
| /**
* Generownaie liczby pseudolosowej całkowitej z przediału [0,(n-1)]
*
* @param n
* @return
*/ | package pl.pmerdala.algs4.std;
import java.util.Random;
public class StdRandom {
private Random random = new Random();
/**
* ustawnienie ziarna pzowala na generowanie zawsze takich samych danych wejściowych
*
* @param seed
*/
public void setSeed(long seed) {
random = new Random(seed);
}
/**
* Generowanie liczby pseudolosowej rzeczywistej z przedziału [0,1)
*
* @return
*/
public double random() {
return random.nextDouble();
}
/**
* Generowanie liczby pseudolosowej rzeczywistej z przedziału [0,1)
*
* @return
*/
public double uniform() {
return random.nextDouble();
}
/**
* Generownaie liczby pseudolosowej <SUF>*/
public int uniform(int n) {
return random.nextInt(n);
}
/**
* Generownaie liczby pseudolosowej całkowitej z przediału [lo, (hi-1)]
*
* @param lo - najmniejsza wartość, hi - największa wartość
* @return
*/
public int uniform(int lo, int hi) {
return lo + uniform(hi - lo);
}
/**
* Generownaie liczby pseudolosowej reczywistej z przediału [lo - hi)
*
* @param lo, hi
* @return
*/
public double uniform(double lo, double hi) {
return lo + random() * (hi - lo);
}
/**
* Zwraca true z prawdopodobieństwem p
*
* @param p - prawdopodobieństo
* @return
*/
public boolean bernoulli(double p) {
return uniform() < p;
}
/**
* Zwraca true z prawdopodobieństwem 50%
*
* @return
*/
public boolean bernoulli() {
return bernoulli(.5);
}
/**
* Generowanie zmiennych losowych o Rozkładzie normalnym, średnia 0, odch. st. 1
*
* @return
*/
public double gaussian() {
double r, x, y;
do {
x = uniform(-1.0, 1.0);
y = uniform(-1.0, 1.0);
r = x * x + y * y;
} while (r >= 1 || r == 0);
return x * Math.sqrt(-2 * Math.log(r) / r);
}
/**
* Rozkład normalny, średnia m, odch. st. s
*
* @return
*/
public double gaussian(double mean, double stddev) {
return mean + stddev * gaussian();
}
/**
* Generowanie zmiennej całkowitej o rozkładzie geometrycznym ze średnią(mean) 1/p
* użyto algorytmu Knuth
*
* @param p
* @return
*/
public int geometric(double p) {
return (int) Math.ceil(Math.log(uniform()) / Math.log(1.0 - p));
}
/**
* Generowanie zmiennej całkowitej o rozkłądznie Poissona ze średnią (mean) lambda.
* uzyto algorytmu Knuth
*
* @param lambda
* @return
* @see "http://en.wikipedia.org/wiki/Poisson_distribution"
*/
public int poisson(double lambda) {
int k = 0;
double p = 1.0;
double L = Math.exp(-lambda);
do {
k++;
p *= uniform();
} while (p >= L);
return k - 1;
}
/**
* Generowanie zmiennej rzeczywistej o rozkładzie pareto z parametrem podziału alpha
*
* @param alpha
* @return
*/
public double pareto(double alpha) {
return Math.pow(1 - uniform(), -1.0 / alpha) - 1.0;
}
/**
* Generowanie zmiennej rzeczywistej o rozkładzie cauchy
* @return
*/
public double cauchy(){
return Math.tan(Math.PI*(uniform()-.5));
}
/**
* Zwraca i z prawdopodobieństwem a[i]
*
* @param a tabela z wartościami rzeczyistymi z [rzedziału [0,1)
* @return
*/
public int discrete(double[] a) {
double r = uniform();
double sum = 0.0;
for (int i = 0; i < a.length; i++) {
sum += a[i];
if(sum>=r) return i;
}
assert(false);
return -1;
}
/**
* Losowo porządkuje elementy tablicy a[]
*
* @param a
*/
public void shuffle(double[] a) {
}
}
| t |
8306_1 | PandkaDEV/TUTORIAL_DATABASE | 298 | TUTORIAL-DATABASE/TUTORIAL/src/main/java/pl/xpawelek/database/manager/UserManager.java | package pl.xpawelek.database.manager;
import org.bukkit.entity.Player;
import pl.xpawelek.database.basic.User;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class UserManager {
public static ConcurrentHashMap<UUID, User> userConcurrentHashMap = new ConcurrentHashMap<>(); // tworzymy mape dzieki ktorej bedziemy mogli przechowywac nasze dane
public static User getUser(Player player){
for(User user : getUserConcurrentHashMap().values()) // pobieramy naszego gracza z wszystkich userow
if(user.getUuid().equals(player.getUniqueId())) // sprawdzamy czy byl kiedys juz w naszej mapie jesli byl zwrocimy mu jego dane
return user;
return new User(player); // jesli gracz nigdy nie byl na serwerze tworzymy go
}
public static ConcurrentHashMap<UUID, User> getUserConcurrentHashMap() {
return userConcurrentHashMap;
}
}
| // pobieramy naszego gracza z wszystkich userow
| package pl.xpawelek.database.manager;
import org.bukkit.entity.Player;
import pl.xpawelek.database.basic.User;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class UserManager {
public static ConcurrentHashMap<UUID, User> userConcurrentHashMap = new ConcurrentHashMap<>(); // tworzymy mape dzieki ktorej bedziemy mogli przechowywac nasze dane
public static User getUser(Player player){
for(User user : getUserConcurrentHashMap().values()) // pobieramy naszego <SUF>
if(user.getUuid().equals(player.getUniqueId())) // sprawdzamy czy byl kiedys juz w naszej mapie jesli byl zwrocimy mu jego dane
return user;
return new User(player); // jesli gracz nigdy nie byl na serwerze tworzymy go
}
public static ConcurrentHashMap<UUID, User> getUserConcurrentHashMap() {
return userConcurrentHashMap;
}
}
| t |
9023_1 | ParfenovichDmitry/Akademia-Envelo | 517 | src/com/task02/Search.java | package com.task02;
public class Search {
public static void main(String[] args) {
int[] numbers = new int[]{45, 1, 1, 1, 0, 0, -3, -5, -48}; //Posortowana tablica w porządku rosnącym
int x = 0; //Liczba
System.out.println(new Search().search(numbers, x)); //Wdrażanie metody search
}
private boolean search(int[] numbers, int x) { //Metoda search
int firstIndex = 0;
int lastIndex = numbers.length - 1;
int midleIndex = (firstIndex + lastIndex) / 2;
/*Jeżeli wartość liczby nie jest większa lub mniejsza niż
maksymalna i minimalna wartości tablicy, to liczba nie może
znajdować się w tej tablicy i nie jest wykonywane dalsze wyszukiwanie.
Złożoność obliczeniową algorytmy O(1), pamięciową O(1)*/
if ((x > numbers[firstIndex]) && (x < numbers[lastIndex])) {
return false;
}
/* Algorytm wyszukiwania binarnego dla podanej liczby.
Z każdą iteracją liczba wyszukiwań zmniejsza się o połowę.
Złożoność obliczeniową algorytmy O(log n), pamięciową O(1)*/
while (firstIndex <= lastIndex) {
if (x == numbers[midleIndex]) {
return true;
} else if (x < numbers[midleIndex]) {
firstIndex = midleIndex + 1;
} else {
lastIndex = midleIndex - 1;
}
midleIndex = (firstIndex + lastIndex) / 2;
}
return false;
}
}
| //Wdrażanie metody search | package com.task02;
public class Search {
public static void main(String[] args) {
int[] numbers = new int[]{45, 1, 1, 1, 0, 0, -3, -5, -48}; //Posortowana tablica w porządku rosnącym
int x = 0; //Liczba
System.out.println(new Search().search(numbers, x)); //Wdrażanie metody <SUF>
}
private boolean search(int[] numbers, int x) { //Metoda search
int firstIndex = 0;
int lastIndex = numbers.length - 1;
int midleIndex = (firstIndex + lastIndex) / 2;
/*Jeżeli wartość liczby nie jest większa lub mniejsza niż
maksymalna i minimalna wartości tablicy, to liczba nie może
znajdować się w tej tablicy i nie jest wykonywane dalsze wyszukiwanie.
Złożoność obliczeniową algorytmy O(1), pamięciową O(1)*/
if ((x > numbers[firstIndex]) && (x < numbers[lastIndex])) {
return false;
}
/* Algorytm wyszukiwania binarnego dla podanej liczby.
Z każdą iteracją liczba wyszukiwań zmniejsza się o połowę.
Złożoność obliczeniową algorytmy O(log n), pamięciową O(1)*/
while (firstIndex <= lastIndex) {
if (x == numbers[midleIndex]) {
return true;
} else if (x < numbers[midleIndex]) {
firstIndex = midleIndex + 1;
} else {
lastIndex = midleIndex - 1;
}
midleIndex = (firstIndex + lastIndex) / 2;
}
return false;
}
}
| t |
2750_0 | Pasjonat90D/Core-Java-for-the-Impatient-Tasks | 249 | src/main/java/com/task/chapter5/task6/Main.java | package com.task.chapter5.task6;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class Main {
public static void main(String[] args) throws IOException {
Path path = Paths.get("cos");
BufferedReader in = null;
try {
in = Files.newBufferedReader(path, StandardCharsets.UTF_8);
String line= "";
while((line = in.readLine())!=null){
}
} catch (IOException ex) {
System.err.println("Przechwycony wyjątek: " + ex.getMessage());
} finally {
if (in != null) {
in.close(); // Ostrzeżenie — może wyrzucić wyjątek
}
}
}
}
| // Ostrzeżenie — może wyrzucić wyjątek | package com.task.chapter5.task6;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class Main {
public static void main(String[] args) throws IOException {
Path path = Paths.get("cos");
BufferedReader in = null;
try {
in = Files.newBufferedReader(path, StandardCharsets.UTF_8);
String line= "";
while((line = in.readLine())!=null){
}
} catch (IOException ex) {
System.err.println("Przechwycony wyjątek: " + ex.getMessage());
} finally {
if (in != null) {
in.close(); // Ostrzeżenie — <SUF>
}
}
}
}
| t |
8320_11 | PawelDabrowski83/javaLearn | 521 | src/main/java/tablice/MainArrays.java | package tablice;
public class MainArrays {
public static void main(String[] args) {
// deklaracja tablicy
int[] array1 = new int[6]; // tablica z 6 elementami (same zera) {0, 0, 0, 0, 0, 0}
int[] array2 = {1, 2, 3, 4, 5, 6}; //tablica inicjalizowana konkretnymi wartościami
// uwaga - indeksy tablicy liczymy od 0 a nie od 1!
// odczytanie elementu z tablicy:
int a, b;
a = array1[0]; // odczytuję liczbę z indeksu '0' (początek tablicy)
b = array1[1]; // odczytuję liczbę z indeksu 1 (czyli drugą w kolejności)
// przypisanie elementu do tablicy:
array1[3] = 7; // wartość 7 przypisuję do elementu nr 3 tablicy (czyli tak naprawdę czwarty element)
// 1. Stwórz tablicę Stringów składającą się z 3 dowolnych słów
// 2. Stwórz tablicę intów o rozmiarze 10 elementów
// 3. Stwórz tablicę charów składającą się z liter: L, o, r, e, m
// 4. Napisz program, który znajduje najniższą wartość w tablicy z p. 3.
// 5. Stwórz tablicę intów o rozmiarze 10. Wypełnij je kolejnymi liczbami, zaczynając od liczby 5.
// 6. Za pomocą pętli zwiększ o 3 wartość każdej liczby z tablicy z p. 5.
}
}
| // 4. Napisz program, który znajduje najniższą wartość w tablicy z p. 3. | package tablice;
public class MainArrays {
public static void main(String[] args) {
// deklaracja tablicy
int[] array1 = new int[6]; // tablica z 6 elementami (same zera) {0, 0, 0, 0, 0, 0}
int[] array2 = {1, 2, 3, 4, 5, 6}; //tablica inicjalizowana konkretnymi wartościami
// uwaga - indeksy tablicy liczymy od 0 a nie od 1!
// odczytanie elementu z tablicy:
int a, b;
a = array1[0]; // odczytuję liczbę z indeksu '0' (początek tablicy)
b = array1[1]; // odczytuję liczbę z indeksu 1 (czyli drugą w kolejności)
// przypisanie elementu do tablicy:
array1[3] = 7; // wartość 7 przypisuję do elementu nr 3 tablicy (czyli tak naprawdę czwarty element)
// 1. Stwórz tablicę Stringów składającą się z 3 dowolnych słów
// 2. Stwórz tablicę intów o rozmiarze 10 elementów
// 3. Stwórz tablicę charów składającą się z liter: L, o, r, e, m
// 4. Napisz <SUF>
// 5. Stwórz tablicę intów o rozmiarze 10. Wypełnij je kolejnymi liczbami, zaczynając od liczby 5.
// 6. Za pomocą pętli zwiększ o 3 wartość każdej liczby z tablicy z p. 5.
}
}
| t |
5795_0 | PawelMozdzynski/Zadanie-Pawel-Mozdzynski | 373 | Zad1.java | package pl.pawelMozdzynski;
class zad1 {
public static void main(String[] args) {
Czlowiek o1 = new Czlowiek();
o1.setImie("Janusz");
o1.setNazwisko("Błaszczyk");
o1.setPESEL("3214321432");
Student student = new Student();
student.setImie("Robert");
student.setNazwisko("Nowak");
student.setPESEL("9283849213");
student.setIndex(472638L);
student.setSrednia(4.5);
Wykladowca wykladowca = new Wykladowca();
wykladowca.setImie("Arkadiusz");
wykladowca.setNazwisko("Patyk");
wykladowca.setPESEL("123456789");
wykladowca.setTytul_naukowy("Doktor");
wykladowca.setPrzedmiot("Fizyka");
System.out.println(wykladowca);
/*
Kiedy tworzymy obiekt klasy podrzędnej najpierw wywołuje się konstruktor klasy nadrzednej
*/
}
}
| /*
Kiedy tworzymy obiekt klasy podrzędnej najpierw wywołuje się konstruktor klasy nadrzednej
*/ | package pl.pawelMozdzynski;
class zad1 {
public static void main(String[] args) {
Czlowiek o1 = new Czlowiek();
o1.setImie("Janusz");
o1.setNazwisko("Błaszczyk");
o1.setPESEL("3214321432");
Student student = new Student();
student.setImie("Robert");
student.setNazwisko("Nowak");
student.setPESEL("9283849213");
student.setIndex(472638L);
student.setSrednia(4.5);
Wykladowca wykladowca = new Wykladowca();
wykladowca.setImie("Arkadiusz");
wykladowca.setNazwisko("Patyk");
wykladowca.setPESEL("123456789");
wykladowca.setTytul_naukowy("Doktor");
wykladowca.setPrzedmiot("Fizyka");
System.out.println(wykladowca);
/*
Kiedy tworzymy obiekt <SUF>*/
}
}
| t |
9126_0 | PawelOzdoba-dev/microservices | 326 | user/src/main/java/pl/app/user/UserApplication.java | package pl.app.user;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableFeignClients
@EnableSwagger2
public class UserApplication {
public static void main(String[] args) {
SpringApplication.run(UserApplication.class, args);
}
}
//zrobić pakiet config w której zrobię RestTemplate klasę w której zrobię bean która zwraca restTemplate i bean ma być oznaczony adnotacją: @LoadBalanced
//w linku muszę wstawić nazwę aplikacji czyli (url) PRODUCT-SERVICE
//zrobić security user
//endpoiinty przenieść z monolitu z usera i produktu.
//elasticsearch co to ? https://smartbees.pl/blog/elasticsearch-czyli-wszystko-o-wyszukiwaniu-pelnotekstowym
//product maven projekt ten jest drugą instancją mikroserwisu PRODUCT-SERVICE - odpalany na porcie 8084.
| //zrobić pakiet config w której zrobię RestTemplate klasę w której zrobię bean która zwraca restTemplate i bean ma być oznaczony adnotacją: @LoadBalanced | package pl.app.user;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableFeignClients
@EnableSwagger2
public class UserApplication {
public static void main(String[] args) {
SpringApplication.run(UserApplication.class, args);
}
}
//zrobić pakiet <SUF>
//w linku muszę wstawić nazwę aplikacji czyli (url) PRODUCT-SERVICE
//zrobić security user
//endpoiinty przenieść z monolitu z usera i produktu.
//elasticsearch co to ? https://smartbees.pl/blog/elasticsearch-czyli-wszystko-o-wyszukiwaniu-pelnotekstowym
//product maven projekt ten jest drugą instancją mikroserwisu PRODUCT-SERVICE - odpalany na porcie 8084.
| t |
3747_0 | PieroganoReggiano/Kvadrato | 626 | src/kvadrato/game/WorldThread.java | package kvadrato.game;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.lang.Runnable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.CancellationException;
/**
* To jest klasa, która ma wątek zajmujący się wszystkim, co się dzieje na
* świecie. Nie jest ona publiczna, ma być widoczna tylko w pakiecie,
*/
class WorldThread extends ScheduledThreadPoolExecutor
{
private World world;
private Future imm;
private ScheduledFuture tim;
/**
* Tutaj też bym coś napisał, ale na razie nie wiem, co.
*/
WorldThread(World w)
{
super(2);
world=w;
}
class Immediately implements Runnable
{
public void run()
{
world.lock();
try
{
while(world.decImmediatelyTicks())
{
world.oneTick();
}
}
finally
{
world.unlock();
}
}
}
class Timed implements Runnable
{
public void run()
{
world.lock();
try
{
world.oneTick();
}
finally
{
world.unlock();
}
}
}
void reschedule()
{
halt();
imm=submit(new Immediately());
if(world.runs())
{
long time=world.getWaitTime();
tim=scheduleAtFixedRate(new Timed(),time,time,TimeUnit.NANOSECONDS);
}
}
void halt()
{
if(imm!=null)
{
imm.cancel(false);
try
{
imm.get();
}
catch(InterruptedException exc){}
catch(ExecutionException exc){}
catch(CancellationException exc){}
imm=null;
}
if(tim!=null)
{
tim.cancel(false);
try
{
tim.get();
}
catch(InterruptedException exc){}
catch(ExecutionException exc){}
catch(CancellationException exc){}
tim=null;
}
}
}
| /**
* To jest klasa, która ma wątek zajmujący się wszystkim, co się dzieje na
* świecie. Nie jest ona publiczna, ma być widoczna tylko w pakiecie,
*/ | package kvadrato.game;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.lang.Runnable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.CancellationException;
/**
* To jest klasa, <SUF>*/
class WorldThread extends ScheduledThreadPoolExecutor
{
private World world;
private Future imm;
private ScheduledFuture tim;
/**
* Tutaj też bym coś napisał, ale na razie nie wiem, co.
*/
WorldThread(World w)
{
super(2);
world=w;
}
class Immediately implements Runnable
{
public void run()
{
world.lock();
try
{
while(world.decImmediatelyTicks())
{
world.oneTick();
}
}
finally
{
world.unlock();
}
}
}
class Timed implements Runnable
{
public void run()
{
world.lock();
try
{
world.oneTick();
}
finally
{
world.unlock();
}
}
}
void reschedule()
{
halt();
imm=submit(new Immediately());
if(world.runs())
{
long time=world.getWaitTime();
tim=scheduleAtFixedRate(new Timed(),time,time,TimeUnit.NANOSECONDS);
}
}
void halt()
{
if(imm!=null)
{
imm.cancel(false);
try
{
imm.get();
}
catch(InterruptedException exc){}
catch(ExecutionException exc){}
catch(CancellationException exc){}
imm=null;
}
if(tim!=null)
{
tim.cancel(false);
try
{
tim.get();
}
catch(InterruptedException exc){}
catch(ExecutionException exc){}
catch(CancellationException exc){}
tim=null;
}
}
}
| t |
6249_18 | Pikei/Metody-podejmowania-Ryzyka | 1,517 | src/HookeJeeves.java | import java.util.Arrays;
import java.util.stream.IntStream;
public class HookeJeeves {
public HookeJeeves() {
algorytm();
}
private final double[] xStart = new double[2]; //punkt startowy, deklaracja wymiarów (x,y,z,...)
private final double[] x = new double[xStart.length]; //punkt, który będzie się poruszać, tyle samo współrzędnych co punkt startowy
private double k = 1.5; //krok
private final double e = 0.00002; //dokładność rozwiązania
private double f(double[] x) { //funkcja f(x) = Σ (i+2)*xi^i
// return IntStream.range(0, x.length).mapToDouble(i -> (i + 2) * Math.pow(x[i], (i))).sum();
return 2 * Math.pow(x[0] - 1.5, 2) + 2 * x[0] * x[1] + Math.pow(x[1] - 0.5, 2) - 3;
}
private void algorytm() {
Arrays.fill(xStart, 2); //początek z punktu (1,1,1,...)
Arrays.setAll(x, i -> xStart[i]);
do {
krokProbny(); //wykonanie kroku próbnego
krokRoboczy(); //wykonanie kroku roboczego
if (f(x) < f(xStart))
Arrays.setAll(xStart, i -> x[i]); //jeśli po wykonaniu kroku punkt jest lepszy to zapisz jego wartość jako aktualną
print(); //wypisanie aktualnego położenia
} while (k > e); //pętla będzie się wykonywać tak długo, dopóki krok będzie większy od e
printResult(); //wypisanie wyniku końcowego
}
private void krokProbny() {
double v = k; //zapisz aktualną wartość kroku
for (int i = 0; i < x.length; i++) { //dla wszystkich wymiarów
x[i] += k; //zmień współrzędną osi o krok
if (f(x) < f(xStart)) { //jeśli nowy punkt jest lepszty niż poprzedni
k = v; //przywróć poprzednią wartość kroku
continue; //przejdź do kolejnej współrzędnej na osi
}
x[i] -= 2 * k; //jeśli zwiększenie współrzędnej nie było lepsze to zmniejsz współrzędną o krok
if (f(x) < f(xStart)) { //jeśli nowy punkt jest lepszty niż poprzedni
k = v; //przywróć poprzednią wartość kroku
continue; //przejdź do kolejnej współrzędnej na osi
}
x[i] = xStart[i]; //jeśli krok w żadną ze stron nie był pomyślny przywróć poprzednią wartość współrzędnej
if (k > e) { //jeśli krok jest większy niż e
k *= 0.2; //zmniejsz krok
i--; //ponów dla tej samej współrzędnej powyższe działania ze zmniejszonym krokiem
} else k = v; //jeśli krok jest mniejszy niż e, przywróć początkową wartość kroku i przejdź do następnej współrzędnej
}
}
private void krokRoboczy() {
double[] tempArray = new double[x.length]; //utwórz tymczasowy punkt, o współrzędnych x
Arrays.setAll(tempArray, i -> x[i]);
Arrays.setAll(x, i -> xStart[i] + 1.5 * (x[i] - xStart[i])); //wykonaj krok po wektorze o długości kroku
if (f(x) < f(tempArray)) k *= 1.25; //jeśli krok był udany zwiększ wartość kroku
else {
Arrays.setAll(x, i -> tempArray[i]); //jeśli nie przywróć poprzednie współrzędne
k *= 0.2; //zmniejsz wartość kroku
}
}
private void print() {
System.out.println("==========================");
System.out.print("aktualny punkt: [");
for (double v : x) {
System.out.print(v + " ");
}
System.out.print("]\n");
System.out.println("aktualne przybliżenie wyniku: " + f(x));
System.out.println("aktualny krok: " + k);
System.out.println("==========================");
}
private void printResult() {
System.out.println("==========WYNIK===========");
System.out.print("Znaleziono minimum funkcji w punkcie: [");
for (double v : x) {
System.out.print(v + " ");
}
System.out.print("]\n");
System.out.println("Wartość funkcji wynosi: " + f(x));
System.out.println("==========================");
}
} | //jeśli nowy punkt jest lepszty niż poprzedni | import java.util.Arrays;
import java.util.stream.IntStream;
public class HookeJeeves {
public HookeJeeves() {
algorytm();
}
private final double[] xStart = new double[2]; //punkt startowy, deklaracja wymiarów (x,y,z,...)
private final double[] x = new double[xStart.length]; //punkt, który będzie się poruszać, tyle samo współrzędnych co punkt startowy
private double k = 1.5; //krok
private final double e = 0.00002; //dokładność rozwiązania
private double f(double[] x) { //funkcja f(x) = Σ (i+2)*xi^i
// return IntStream.range(0, x.length).mapToDouble(i -> (i + 2) * Math.pow(x[i], (i))).sum();
return 2 * Math.pow(x[0] - 1.5, 2) + 2 * x[0] * x[1] + Math.pow(x[1] - 0.5, 2) - 3;
}
private void algorytm() {
Arrays.fill(xStart, 2); //początek z punktu (1,1,1,...)
Arrays.setAll(x, i -> xStart[i]);
do {
krokProbny(); //wykonanie kroku próbnego
krokRoboczy(); //wykonanie kroku roboczego
if (f(x) < f(xStart))
Arrays.setAll(xStart, i -> x[i]); //jeśli po wykonaniu kroku punkt jest lepszy to zapisz jego wartość jako aktualną
print(); //wypisanie aktualnego położenia
} while (k > e); //pętla będzie się wykonywać tak długo, dopóki krok będzie większy od e
printResult(); //wypisanie wyniku końcowego
}
private void krokProbny() {
double v = k; //zapisz aktualną wartość kroku
for (int i = 0; i < x.length; i++) { //dla wszystkich wymiarów
x[i] += k; //zmień współrzędną osi o krok
if (f(x) < f(xStart)) { //jeśli nowy punkt jest lepszty niż poprzedni
k = v; //przywróć poprzednią wartość kroku
continue; //przejdź do kolejnej współrzędnej na osi
}
x[i] -= 2 * k; //jeśli zwiększenie współrzędnej nie było lepsze to zmniejsz współrzędną o krok
if (f(x) < f(xStart)) { //jeśli nowy <SUF>
k = v; //przywróć poprzednią wartość kroku
continue; //przejdź do kolejnej współrzędnej na osi
}
x[i] = xStart[i]; //jeśli krok w żadną ze stron nie był pomyślny przywróć poprzednią wartość współrzędnej
if (k > e) { //jeśli krok jest większy niż e
k *= 0.2; //zmniejsz krok
i--; //ponów dla tej samej współrzędnej powyższe działania ze zmniejszonym krokiem
} else k = v; //jeśli krok jest mniejszy niż e, przywróć początkową wartość kroku i przejdź do następnej współrzędnej
}
}
private void krokRoboczy() {
double[] tempArray = new double[x.length]; //utwórz tymczasowy punkt, o współrzędnych x
Arrays.setAll(tempArray, i -> x[i]);
Arrays.setAll(x, i -> xStart[i] + 1.5 * (x[i] - xStart[i])); //wykonaj krok po wektorze o długości kroku
if (f(x) < f(tempArray)) k *= 1.25; //jeśli krok był udany zwiększ wartość kroku
else {
Arrays.setAll(x, i -> tempArray[i]); //jeśli nie przywróć poprzednie współrzędne
k *= 0.2; //zmniejsz wartość kroku
}
}
private void print() {
System.out.println("==========================");
System.out.print("aktualny punkt: [");
for (double v : x) {
System.out.print(v + " ");
}
System.out.print("]\n");
System.out.println("aktualne przybliżenie wyniku: " + f(x));
System.out.println("aktualny krok: " + k);
System.out.println("==========================");
}
private void printResult() {
System.out.println("==========WYNIK===========");
System.out.print("Znaleziono minimum funkcji w punkcie: [");
for (double v : x) {
System.out.print(v + " ");
}
System.out.print("]\n");
System.out.println("Wartość funkcji wynosi: " + f(x));
System.out.println("==========================");
}
} | t |
7105_0 | PiotrDeda/labs-po2 | 523 | Lab6/ListaLiczb.java | public class ListaLiczb extends Lista
{
public void add(Liczba obj)
{
super.add(obj);
}
public void add(Object obj)
throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
public Object smallestValue()
{
Node smallest = root;
Node currNode = root;
while (currNode.next != null)
{
if (((Liczba) currNode.next.obj).toDouble() < ((Liczba) smallest.obj).toDouble())
smallest = currNode.next;
currNode = currNode.next;
}
return smallest.obj;
}
public Object largestValue()
{
Node largest = root;
Node currNode = root;
while (currNode.next != null)
{
if (((Liczba) currNode.next.obj).toDouble() > ((Liczba) largest.obj).toDouble())
largest = currNode.next;
currNode = currNode.next;
}
return largest.obj;
}
public double[] toArray()
{
double[] result = new double[size()];
Node currNode = root;
int i = 0;
while (currNode != null)
{
result[i] = ((Liczba) currNode.obj).toDouble();
i += 1;
currNode = currNode.next;
}
return result;
}
public double average()
{
double[] arr = toArray();
double sum = 0;
for (double n : arr)
sum += n;
return sum / size();
}
public void sort()
{
// sortowanie jeszcze niezrealizowane, może kiedyś do niego wrócę
}
} | // sortowanie jeszcze niezrealizowane, może kiedyś do niego wrócę | public class ListaLiczb extends Lista
{
public void add(Liczba obj)
{
super.add(obj);
}
public void add(Object obj)
throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
public Object smallestValue()
{
Node smallest = root;
Node currNode = root;
while (currNode.next != null)
{
if (((Liczba) currNode.next.obj).toDouble() < ((Liczba) smallest.obj).toDouble())
smallest = currNode.next;
currNode = currNode.next;
}
return smallest.obj;
}
public Object largestValue()
{
Node largest = root;
Node currNode = root;
while (currNode.next != null)
{
if (((Liczba) currNode.next.obj).toDouble() > ((Liczba) largest.obj).toDouble())
largest = currNode.next;
currNode = currNode.next;
}
return largest.obj;
}
public double[] toArray()
{
double[] result = new double[size()];
Node currNode = root;
int i = 0;
while (currNode != null)
{
result[i] = ((Liczba) currNode.obj).toDouble();
i += 1;
currNode = currNode.next;
}
return result;
}
public double average()
{
double[] arr = toArray();
double sum = 0;
for (double n : arr)
sum += n;
return sum / size();
}
public void sort()
{
// sortowanie jeszcze <SUF>
}
} | t |
7738_0 | PiotrSmola/Studies---Object-oriented-programming | 859 | Lab02/ex4.java | import java.util.Scanner;
public class ex4 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] tablica = new int[10];
System.out.println("Wprowadź 10 liczb:");
for (int i = 0; i < 10; i++) {
tablica[i] = in.nextInt();
}
int suma = 0;
int iloczyn = 1;
double srednia = 0;
int min = tablica[0];
int max = tablica[0];
for (int i = 0; i < tablica.length; i++) {
suma += tablica[i];
iloczyn *= tablica[i];
if (tablica[i] < min) {
min = tablica[i];
}
if (tablica[i] > max) {
max = tablica[i];
}
}
srednia = (double)suma/tablica.length;
while(true) {
System.out.println("\nMENU:");
System.out.println("1. Suma elementów tablicy");
System.out.println("2. Iloczyn elementów tablicy");
System.out.println("3. Średnia wartość elementów tablicy");
System.out.println("4. Wartość minimalna");
System.out.println("5. Wartość maksymalna");
System.out.println("6. Wyjście");
System.out.print("\nWybierz opcję: ");
int wybor = in.nextInt();
switch (wybor) {
case 1:
System.out.println("Suma elementów tablicy: " + suma);
break;
case 2:
System.out.println("Iloczyn elementów tablicy: " + iloczyn);
break;
case 3:
System.out.println("Średnia wartość elementów tablicy: " + srednia);
break;
case 4:
System.out.println("Wartość minimalna: " + min);
break;
case 5:
System.out.println("Wartość maksymalna: " + max);
break;
case 6:
Close();
default:
Error();
break;
}
}
}
public static void Error()
{
System.out.println("Błędne dane, koniec programu");
System.exit(0);
}
public static String InputString() { //potwierdzenie zakończenia programu
Scanner input = new Scanner(System.in);
String znak = input.nextLine();
return znak;
}
public static void Close() {
System.out.println("\t\t\tCzy na pewno chcesz wyjść t || T");
String znak = InputString();
String st1="t";
String st2="T";
if (znak.equals(st1) || znak.equals(st2)) System.exit(0);
}
}
| //potwierdzenie zakończenia programu
| import java.util.Scanner;
public class ex4 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] tablica = new int[10];
System.out.println("Wprowadź 10 liczb:");
for (int i = 0; i < 10; i++) {
tablica[i] = in.nextInt();
}
int suma = 0;
int iloczyn = 1;
double srednia = 0;
int min = tablica[0];
int max = tablica[0];
for (int i = 0; i < tablica.length; i++) {
suma += tablica[i];
iloczyn *= tablica[i];
if (tablica[i] < min) {
min = tablica[i];
}
if (tablica[i] > max) {
max = tablica[i];
}
}
srednia = (double)suma/tablica.length;
while(true) {
System.out.println("\nMENU:");
System.out.println("1. Suma elementów tablicy");
System.out.println("2. Iloczyn elementów tablicy");
System.out.println("3. Średnia wartość elementów tablicy");
System.out.println("4. Wartość minimalna");
System.out.println("5. Wartość maksymalna");
System.out.println("6. Wyjście");
System.out.print("\nWybierz opcję: ");
int wybor = in.nextInt();
switch (wybor) {
case 1:
System.out.println("Suma elementów tablicy: " + suma);
break;
case 2:
System.out.println("Iloczyn elementów tablicy: " + iloczyn);
break;
case 3:
System.out.println("Średnia wartość elementów tablicy: " + srednia);
break;
case 4:
System.out.println("Wartość minimalna: " + min);
break;
case 5:
System.out.println("Wartość maksymalna: " + max);
break;
case 6:
Close();
default:
Error();
break;
}
}
}
public static void Error()
{
System.out.println("Błędne dane, koniec programu");
System.exit(0);
}
public static String InputString() { //potwierdzenie zakończenia <SUF>
Scanner input = new Scanner(System.in);
String znak = input.nextLine();
return znak;
}
public static void Close() {
System.out.println("\t\t\tCzy na pewno chcesz wyjść t || T");
String znak = InputString();
String st1="t";
String st2="T";
if (znak.equals(st1) || znak.equals(st2)) System.exit(0);
}
}
| t |
9997_1 | PiotrStoklosa/uwr-first-cycle-studies | 882 | semestr III/kurs-jezyka-java/zadanie1/spirala.java | //Piotr Stokłosa Zadanie1
public class Spirala {
private static final boolean[] sieve = new boolean[40001];
static boolean ifPrimary(int number){
return !sieve[number];
}
static void fillingTheSieve(){
sieve[0] = true;
sieve[1] = true;
for (int i = 2; i < 40001; i++)
if (!sieve[i])
for (int j = i * i; j < 40001; j += i)
sieve[j] = true;
}
static void fillingTheSpiral(int[][] spiral, int n){
int start = n / 2;
int max = 2; // (maks / 2) oznacza ile powinien algorytm przypisac liczb w jednej lini
int currentMax = 1; // oznacza ile jeszcze trzeba przypisac liczb przed zmiana kierunku
int currentx = n % 2 == 0 ? start - 1 : start; // miejsce od ktorego zaczynamy
int currenty = start; // miejsce od ktorego zaczynamy
int direction = 0; // wschod = 0, polnoc = 1, zachod = 2; poludnie = 3
for (int i = 1; i <= n * n; i++){
spiral[currenty][currentx] = i;
if (currentMax == 0){ // jesli prawda trzeba zmienic kierunek
max++;
currentMax = max / 2;
direction++;
if (direction == 4)
direction = 0;
}
if (direction == 0) // zmiana parametru zaleznie od kierunku w ktorym idzie algorytm
currentx++;
if (direction == 1)
currenty--;
if (direction == 2)
currentx--;
if (direction == 3)
currenty++;
currentMax--;
}
}
static void fillingWithZeros(int[][] spiral, int n){
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (!ifPrimary(spiral[i][j]))
spiral[i][j] = 0;
}
static void printingTheSpiral(int[][] spiral, int n){
for (int i=0; i<n; i++) {
for (int j = 0; j < n; j++)
if (spiral[i][j] != 0)
System.out.print("* ");
else
System.out.print(" ");
System.out.print('\n');
}
}
public static void main(String[] args){
int size = Integer.parseInt(args[0]);
if (size < 2 || size > 200)
throw new IllegalArgumentException("parametr spoza zakresu 2...200");
int[][] spiral = new int[size][size];
fillingTheSieve();
fillingTheSpiral(spiral, size);
fillingWithZeros(spiral, size);
printingTheSpiral(spiral, size);
}
}
| // (maks / 2) oznacza ile powinien algorytm przypisac liczb w jednej lini | //Piotr Stokłosa Zadanie1
public class Spirala {
private static final boolean[] sieve = new boolean[40001];
static boolean ifPrimary(int number){
return !sieve[number];
}
static void fillingTheSieve(){
sieve[0] = true;
sieve[1] = true;
for (int i = 2; i < 40001; i++)
if (!sieve[i])
for (int j = i * i; j < 40001; j += i)
sieve[j] = true;
}
static void fillingTheSpiral(int[][] spiral, int n){
int start = n / 2;
int max = 2; // (maks / <SUF>
int currentMax = 1; // oznacza ile jeszcze trzeba przypisac liczb przed zmiana kierunku
int currentx = n % 2 == 0 ? start - 1 : start; // miejsce od ktorego zaczynamy
int currenty = start; // miejsce od ktorego zaczynamy
int direction = 0; // wschod = 0, polnoc = 1, zachod = 2; poludnie = 3
for (int i = 1; i <= n * n; i++){
spiral[currenty][currentx] = i;
if (currentMax == 0){ // jesli prawda trzeba zmienic kierunek
max++;
currentMax = max / 2;
direction++;
if (direction == 4)
direction = 0;
}
if (direction == 0) // zmiana parametru zaleznie od kierunku w ktorym idzie algorytm
currentx++;
if (direction == 1)
currenty--;
if (direction == 2)
currentx--;
if (direction == 3)
currenty++;
currentMax--;
}
}
static void fillingWithZeros(int[][] spiral, int n){
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (!ifPrimary(spiral[i][j]))
spiral[i][j] = 0;
}
static void printingTheSpiral(int[][] spiral, int n){
for (int i=0; i<n; i++) {
for (int j = 0; j < n; j++)
if (spiral[i][j] != 0)
System.out.print("* ");
else
System.out.print(" ");
System.out.print('\n');
}
}
public static void main(String[] args){
int size = Integer.parseInt(args[0]);
if (size < 2 || size > 200)
throw new IllegalArgumentException("parametr spoza zakresu 2...200");
int[][] spiral = new int[size][size];
fillingTheSieve();
fillingTheSpiral(spiral, size);
fillingWithZeros(spiral, size);
printingTheSpiral(spiral, size);
}
}
| t |