Új hozzászólás Aktív témák
-
Ja maradt az arraylist, az a legkézenfekvőbb. De valamiért, a leadó system testje vmiert ezt a hibát írja ki:
Removed two elements but the second one had a lower priority than the first one! Amit nem értek. Amugy itt van a programom(class nevet most atneveztem):
import java.util.ArrayList;
public class MyPriorityQueue<T extends Comparable<T>> {
private ArrayList<T> queue;
private int maxElements;
public MyPriorityQueue(int maxElements){
this.maxElements = maxElements;
queue = new ArrayList<T>();
}
public void add(T e) throws IllegalStateException{
if( size() == maxElements)
throw new IllegalStateException("The queue is already full!");
queue.add(e);
int i = size()-1 ;
T help;
while ( i > 0 && ( queue.get( parent(i) ).compareTo( queue.get(i) ) ) > 0 ){
help = queue.get(i);
queue.set(i,queue.get( parent(i) ));
queue.set(parent(i), help);
i = parent(i);
}
}
public T pop() throws IllegalStateException{
if(queue.isEmpty())
throw new IllegalStateException("The queue is empty!");
T min = queue.get(0);
queue.remove(0);
minheapify(0);
return min;
}
public int size(){
return queue.size();
}
public int parent(int i){
return (i - 1) / 2;
}
public void minheapify(int i){
int l = i*2+1;
int r = l+1;
int min;
T help;
if (l <= size()-1 && ( queue.get(l).compareTo( queue.get(i) ) ) < 0 )
min = l;
else
min = i;
if (r <= size()-1 && ( queue.get(r).compareTo( queue.get(min) ) ) < 0)
min = r;
if (min != i){
help = queue.get(i);
queue.set(i,queue.get(min));
queue.set(min, help);
minheapify(min);
}
}
public void display(){
for(int i = 0; i < queue.size(); i++) {
System.out.print(queue.get(i) + " ");
}
}
} -
1. En ugy ertenem a feladatot ahogy a tobbiek irtak (nem a java.util-ost definialod felul, hanem azt nem include-olva magad irsz egyet)
2. Ha igy teszel, miert baj az, hogy a beepitett is minheap-et hasznal? ArrayList, megirod a minheap-nek a sullyeszt meg buborekol vagy hogy hivtatok fuggvenyet, vagy hat kozvetlen beleirod az add/pop kodjaba, es ennyi.
Bar a maxelements miatt akar sima tombot is hasznalhatsz, persze akkor kulon kell tarolni es managelni a size aktualis erteket (vagy legalabbis erdemes, ha nem akarod mindig megkeresni az elso null-t). Felesleges ha ott az arraylist bekorlatozni magad, de lehet, hogy iskolapeldakent inkabb azt irnam meg. -
Mivel a PriorityQueue a java.util-ban van, ezért ha nem húzod be importtal, nem fognak "összeakadni"
Amúgy meg ha kellene mindkettő ugyanabban az osztályban, akkor az egyiket teljes eléréssel (pl. java.util.PriorityQueue), a másikat importálva tudod használni.Amúgy a feladatom az lenne, hogy saját kezűleg kell implementalni egy priorityqueque-t, minheap struktúrával,
az alábbi interface segitsegevel:/**
* Manages elements within a priority queue. All Elements in this queue must
* implement the Comparable interface. If a element is requested from this data
* structure the smallest one is returned. If there are multiple smallest
* elements, one of them must be returned.
*/
public class PriorityQueue<T extends Comparable<T>> {
/**
* @param maxElements The maximum number of elements this queue can hold.
*/
public PriorityQueue(int maxElements);
/**
* Add e to the queue.
*
* @param e The element which sould be inserted (at the correct position) into the queue.
* @throws IllegalStateException if the queue is already full
*/
public void add(T e) throws IllegalStateException;
/**
* Returns and removes the smallest element in the queue.
*
* @return the smallest element
* @throws IllegalStateException if the queue is empty
*/
public T pop() throws IllegalStateException;
/**
* Return the current number of elements in the queue.
*
* @return the number of elements
*/
public int size();
}Es nem tudom, hogy milyen classot használhatnék e szerint az adatok belső menedzselésére.
A baj az, hogy a beepitett java PriorityQueue is minheapet használ.LinkedList<E> ill. ArrayList<E> szeretnek használni hozza.
Vagy a fenti feladat azt jelenti, hogy a bepitett PriorityQueue-hoz felülirom a pop() es add() metódusokat?
De akkor meg nem tudok indexeket hasznalni, és az algoritmus alapján szerintem mindenképpen olyan kell, ami indexelhető. Nem tudom ...
-
-
@emvy , @disy68, thx. Vegul sikerült egyszerűbben megoldanom, de újabb problémába akadtam..
Gyorsrendezést kellene kivitelezni javaban, úgy hogy pivotkent mindig a résztömb utolsó két elemének a lekerekített átlagát kell venni. A kódom működik, úgy ha a pivot mindig résztömb utolsó eleme. Az előző verzióval vmi félrecsúszik. Hálás lennek ha valaki bele tudna kukkantani.
Itt a teszt hozza:
class gyors {
public static void main(String[] args) {
Integer [] a = {-8, -2, -4, -3, -10, -4, -9, -2, -9, -11};
qyors(a,0,a.length-1);
for (int j = 0; j < a.length ; j++) {
System.out.print(a[j] + " ");
}
}
public static void qyors(Integer [] a, int p, int r){
if ( p < r){
int q = Partition(a,p,r);
qyors(a, p, q - 1);
qyors(a, q + 1 , r);
}
}
public static int Partition(Integer [] a, int p, int r){
Integer x = (a[r]+a[r-1])/2; //a resztomb utolso ket elemenek a lekerekitett atlaga kene pivotnak
//Integer x = a[r]; //ezzel mukodik
int i = p - 1;
Integer help;
for (int j = p; j < r ; j++) {
if( a[j] <= x ){
i++;
help = a[i];
a[i] = a[j];
a[j] = help;
}
}
help = a[i+1];
a[i+1] = a[r];
a[r] = help;
return i+1;
}
} -
#74220800
törölt tag
@emvy , @disy68, thx. Vegul sikerült egyszerűbben megoldanom, de újabb problémába akadtam..
Gyorsrendezést kellene kivitelezni javaban, úgy hogy pivotkent mindig a résztömb utolsó két elemének a lekerekített átlagát kell venni. A kódom működik, úgy ha a pivot mindig résztömb utolsó eleme. Az előző verzióval vmi félrecsúszik. Hálás lennek ha valaki bele tudna kukkantani.
Itt a teszt hozza:
class gyors {
public static void main(String[] args) {
Integer [] a = {-8, -2, -4, -3, -10, -4, -9, -2, -9, -11};
qyors(a,0,a.length-1);
for (int j = 0; j < a.length ; j++) {
System.out.print(a[j] + " ");
}
}
public static void qyors(Integer [] a, int p, int r){
if ( p < r){
int q = Partition(a,p,r);
qyors(a, p, q - 1);
qyors(a, q + 1 , r);
}
}
public static int Partition(Integer [] a, int p, int r){
Integer x = (a[r]+a[r-1])/2; //a resztomb utolso ket elemenek a lekerekitett atlaga kene pivotnak
//Integer x = a[r]; //ezzel mukodik
int i = p - 1;
Integer help;
for (int j = p; j < r ; j++) {
if( a[j] <= x ){
i++;
help = a[i];
a[i] = a[j];
a[j] = help;
}
}
help = a[i+1];
a[i+1] = a[r];
a[r] = help;
return i+1;
}
} -
Na az előző verzió majdnem jó. Valamiért néha sorokon vagy oszlopokon belül berakja egymás mellé a hajókat. Kiszedtem belőle egy kisebb reszt. Ez a hatodik sorba próbál berakni két darab 4es hajót véletlenül.
Sajnos néha egymás mellé.. Valaki jöjjön plsssssssssss.public class Tesztsor{ //java Tesztsor
public static void main(String[] args){
int [] randomatrix ={0,1,2,3,4,5,6,7,8,9};
boolean[][] hajok = new boolean [10][10];
for(int j = 0; j < randomatrix.length; j++){
int w = (int)(Math.random()*10);
int g = randomatrix[w];
randomatrix[w] = randomatrix[j];
randomatrix[j] = g;
}
hajokatSorra(5, randomatrix, 4, hajok);
hajokatSorra(5, randomatrix, 4, hajok);
for(int i = 0; i < hajok.length; i++){
for(int j = 0; j < hajok[i].length; j++){
if (hajok[i][j])
System.out.print("H");
else
System.out.print("-");
}
System.out.println();
}
}
public static boolean hajokatSorra(int x, int[] arr, int size, boolean[][] hajok ){
boolean shipreadyleft = false;
boolean shipreadyright = false;
for( int k = 0; k < arr.length; k++){
int point = arr[k];
for( int j = point; j >= 0; j--){
if( hajok[x][j] ){
if ( point - j >= 2 ) shipreadyleft =true;
break;
}
if( hajok[ Math.max(0,x-1)][j] || hajok[ Math.min(9,x+1)][j] ){
if (point - j >= 1 ) shipreadyleft =true;
break;
}
if( j == 0 ) shipreadyleft =true;
}
if (shipreadyleft){
for( int j = point; j < hajok.length; j++){
if( hajok[x][j] ){
if( j - point >= size + 1 ) shipreadyright =true;
break;
}
if( hajok[ Math.max(0,x-1)][j] || hajok[ Math.min(9,x+1)][j] ){
if ( j - point >= size ) shipreadyright =true;
break;
}
if( j == hajok.length - 1 && hajok.length - 1 - point >= size - 1 ) shipreadyright =true;
}
}
if ( shipreadyright ){
for( int j = point; j - point + 1 <= size; j++){
hajok[x][j] = true;
}
}
if ( shipreadyright && shipreadyleft) break;
}
return shipreadyright && shipreadyleft;
}
} -
Najo hajotSorra() es a hajotOszlopra() metódusoknál elszámoltam magam.De meg mindig nem jő. Ha van aki velem számol (9244,9245 hozz), itt a frissitett verzio:
public class torpedo {
private final int rows;
private final int cols;
private final boolean[][] hits;
private final boolean[][] ships;
public torpedo (int numRows, int numCols) {
this.rows = numRows;
this.cols = numCols;
this.hits = new boolean[rows][cols];
this.ships = new boolean[rows][cols];
}
public void startGame() {
placeShips();
printfield();
}
private void placeShips() {
int [] shiporder ={2,2,2,2,3,3,3,4,4,5};
for(int j = 0; j < shiporder.length; j++){
int n = (int)(Math.random()*10);
int b = shiporder[n];
shiporder[n] = shiporder[j];
shiporder[j] = b;
}
int [] randomarray ={0,1,2,3,4,5,6,7,8,9};
for(int j = 0; j < randomarray.length; j++){
int w = (int)(Math.random()*10);
int g = randomarray[w];
randomarray[w] = randomarray[j];
randomarray[j] = g;
}
for(int j = 0; j < shiporder.length; j++){
int ship = shiporder[j];
int e = (int)(Math.random()*2);
if ( e == 0 && (hajotVizszintesre( randomarray, ship) ||hajotFuggolegesre( randomarray, ship ) ));
if ( e == 1 && ( hajotFuggolegesre( randomarray, ship) || hajotVizszintesre( randomarray, ship ) ));
}
}
public boolean hajotSorra(int x, int[] arr, int size){
boolean shipreadyleft = false;
boolean shipreadyright = false;
for( int k = 0; k < arr.length; k++){
int point = arr[k];
for( int j = point; j >= 0; j--){
if( ships[x][j] ){
if ( point - j >= 2 ) shipreadyleft =true;
break;
}
if( ships[ Math.max(0,x-1)][j] || ships[ Math.min(9,x+1)][j] ){
if (point - j >= 1 ) shipreadyleft =true;
break;
}
if( j == 0 ) shipreadyleft =true;
}
if (shipreadyleft){
for( int j = point; j < ships.length; j++){
if( ships[x][j] ){
if( j - point >= size + 1 ) shipreadyright =true;
break;
}
if( ships[ Math.max(0,x-1)][j] || ships[ Math.min(9,x+1)][j] ){
if ( j - point >= size ) shipreadyright =true;
break;
}
if( j == ships.length - 1 && ships.length - 1 - point >= size - 1 ) shipreadyright =true;
}
}
if ( shipreadyright ){
for( int j = point; j - point + 1 <= size; j++){
ships[x][j] = true;
}
}
if ( shipreadyright && shipreadyleft) break;
}
return shipreadyright && shipreadyleft;
}
public boolean hajotOszlopra (int y, int[] arr, int size){
boolean shipreadyup = false;
boolean shipreadydown = false;
for( int k = 0; k < arr.length; k++){
int point = arr[k];
for( int j = point; j >= 0; j--){
if( ships[j][y] ){
if (point - j >= 2) shipreadyup =true;
break;
}
if( ships[j][ Math.max(0,y-1)] || ships[j][Math.min(9,y+1)]){
if (point - j >= 1) shipreadyup =true;
break;
}
if( j == 0 ) shipreadyup =true;
}
if (shipreadyup){
for( int j = point; j < ships.length; j++){
if( ships[j][y]){
if (j - point >= size + 1 ) shipreadydown =true;
break;
}
if(ships[j][ Math.max(0,y-1)] || ships[j][Math.min(9,y+1)]){
if (j - point >= size ) shipreadydown =true;
break;
}
if( j == ships.length - 1 && ships.length - 1 - point >= size - 1 ) shipreadydown =true;
}
}
if ( shipreadydown ){
for( int j = point; j - point + 1 <= size; j++){
ships[j][y] = true;
}
}
if ( shipreadydown && shipreadyup ) break;
}
return shipreadydown && shipreadyup;
}
public boolean hajotVizszintesre(int[] arr, int size){
for( int k = 0; k < arr.length; k++){
int p1 = arr[k];
if ( hajotSorra(p1, arr, size)) return true;
}
return false;
}
public boolean hajotFuggolegesre(int[] arr, int size){
for( int k = 0; k < arr.length; k++){
int p2 = arr[k];
if ( hajotOszlopra(p2, arr, size )) return true;
}
return false;
}
public void printfield(){
for(int i = 0; i < ships.length; i++){
for(int j = 0; j < ships[i].length; j++){
if (ships[i][j])
System.out.print("H");
else
System.out.print("-");
}
System.out.println();
}
}
} -
Sziasztok!
Segítségeteket kérném. Le kell adnom egy torpedó játékot, úgy érzem a koncepcióm jó, de valahol valami félrecsúszott a megvalósításban. Közeleg a határidő, és a sorok kezdenek összefolyni, A kódom szerintem jó strukturált, nem hosszú, és a téma is érdekes. Örülnek ha valaki bele tudna kukkantani.
Szóval egy 10*10 mezőre kéne feldobni véletlenszerűen 10 darab hajót (4db 2es méretűt, 3db 3as, 2 db 4es, 1db 5os) vízszintesen vagy függőlegesen, úgy hogy a hajók csak a sarkoknál érintkezhetnek, máshol egy szabad helyet kell hagyni közöttük.
Algoritmusom a következő:
-Generálok egy véletlen sorrendű mátrixot a hajók méreteivel, és eszerint próbálom őket felpakolni a fieldre.
-generálok egy véletlen számot, hogy a hajót először vízszintesen (addig megyek a sorokban amíg találok neki helyet) vagy függőlegesen( addig....az oszlopokban..) próbálja felrakni
-Generálok egy másik véletlen sorrendű mátrixot a field index számaival. Az index egyrészt a sorokra vagy oszlopokra tett próbálkozások, ill. az adott sorban vagy oszlopban a hajó kezdőpontjára tett kísérleteknek a sorrendjét is jelöli. Minden hajót eszerint próbálok feltenni.
-Ha egy hajót se egyik sorrba se egyik oszlopba nem lehet berakni, kezdődik a cirkusz előröl. (ide a loop meg hianyzik)
-Biztos van sokkal jobba algoritmus az enyémnél, hatékonysága kérdéses, de ha nem elvetemült az ötletem, ragaszkodnék az enyémhez (idő hiánya miatt is), ezt kéne valahogy működésre bírni....
Néhány metódus magyarázat:
hajotSorra(int x, int[] arr, int size): a size méretű hajót próbálja berakni az x.dik sorba, az arr matrix szerinti kezdőpontsorrenddel balról jobbra.
hajotOszlopra(int y, int[] arr, int size): a size méretű hajót próbálja berakni az y.dik oszlopba, az arr matrix szerinti kezdőpontsorrenddel fentről lefele.
hajotVizszintesre(int[] arr, int size): a hajot az arr szerinti sorsorrendbe próbálja berakni valamelyik sorba.
public boolean hajotFuggolegesre: a hajot az arr szerinti oszlopsorrendbe próbálja berakni valamelyik oszlopba.
Es a kicsike:
public class torpedo {
private final int rows;
private final int cols;
private final boolean[][] hits;
private final boolean[][] ships;
public torpedo (int numRows, int numCols) {
this.rows = numRows;
this.cols = numCols;
this.hits = new boolean[rows][cols];
this.ships = new boolean[rows][cols];
}
public void startGame() {
placeShips();
printfield();
}
private void placeShips() {
int [] shiporder ={2,2,2,2,3,3,3,4,4,5};
for(int j = 0; j < shiporder.length; j++){
int n = (int)(Math.random()*10);
int b = shiporder[n];
shiporder[n] = shiporder[j];
shiporder[j] = b;
}
int [] randomarray ={0,1,2,3,4,5,6,7,8,9};
for(int j = 0; j < randomarray.length; j++){
int w = (int)(Math.random()*10);
int g = randomarray[w];
randomarray[w] = randomarray[j];
randomarray[j] = g;
}
for(int j = 0; j < shiporder.length; j++){
int ship = shiporder[j];
int e = (int)(Math.random()*2);
if ( e == 0 && (hajotVizszintesre( randomarray, ship) ||hajotFuggolegesre( randomarray, ship ) ));
if ( e == 1 && ( hajotFuggolegesre( randomarray, ship) || hajotVizszintesre( randomarray, ship ) ));
}
}
public boolean hajotSorra(int x, int[] arr, int size){
boolean shipreadyleft = false;
boolean shipreadyright = false;
for( int k = 0; k < arr.length; k++){
int point = arr[k];
for( int j = point; j >= 0; j--){
if( ships[x][j] || ships[ Math.max(0,x-1)][j] || ships[ Math.min(9,x+1)][j] ){
if (point - j >= 2) shipreadyleft =true;
break;
}
if( !ships[x][0] && !ships[ Math.max(0,x-1)][0] && !ships[ Math.min(9,x+1)][0] ) shipreadyleft =true;
}
if (shipreadyleft){
for( int j = point; j < ships.length; j++){
if( ships[x][j] || ships[ Math.max(0,x-1)][j] || ships[ Math.min(9,x+1)][j]){
if (j - point >= size + 1 ) shipreadyright =true;
break;
}
if( !ships[x][ships.length-1] && !ships[ Math.max(0,x-1)][ships.length-1] && !ships[ Math.min(9,x+1)][ships.length-1] && ships.length - 1 - point >= size + 1 ) shipreadyright =true;
}
}
if ( shipreadyright ){
for( int j = point; j - point + 1 <= size; j++){
ships[x][j] = true;
}
}
if ( shipreadyright && shipreadyleft) break;
}
return shipreadyright && shipreadyleft;
}
public boolean hajotOszlopra(int y, int[] arr, int size){
boolean shipreadyup = false;
boolean shipreadydown = false;
for( int k = 0; k < arr.length; k++){
int point = arr[k];
for( int j = point; j >= 0; j--){
if( ships[j][y] || ships[j][ Math.max(0,y-1)] || ships[j][Math.min(9,y+1)] ){
if (point - j >= 2) shipreadyup =true;
break;
}
if( !ships[0][y] && !ships[0][ Math.max(0,y-1)] && !ships[0][Math.min(9,y+1)] ) shipreadyup =true;
}
if (shipreadyup){
for( int j = point; j < ships.length; j++){
if( ships[j][y] || ships[j][ Math.max(0,y-1)] || ships[j][Math.min(9,y+1)]){
if (j - point >= size + 1 ) shipreadydown =true;
break;
}
if( !ships[ships.length-1][y] && !ships[ships.length-1][ Math.max(0,y-1)] && !ships[ships.length-1][Math.min(9,y+1)] && ships.length - 1 - point >= size + 1 ) shipreadydown =true;
}
}
if ( shipreadydown ){
for( int j = point; j - point + 1 <= size; j++){
ships[j][y] = true;
}
}
if ( shipreadydown && shipreadyup ) break;
}
return shipreadydown && shipreadyup;
}
public boolean hajotVizszintesre(int[] arr, int size){
for( int k = 0; k < arr.length; k++){
int p1 = arr[k];
if ( hajotSorra(p1, arr, size)) return true;
}
return false;
}
public boolean hajotFuggolegesre(int[] arr, int size){
for( int k = 0; k < arr.length; k++){
int p2 = arr[k];
if ( hajotOszlopra(p2, arr, size )) return true;
}
return false;
}
public void printfield(){
for(int i = 0; i < ships.length; i++){
for(int j = 0; j < ships[i].length; j++){
if (ships[i][j])
System.out.print("H");
else
System.out.print("-");
}
System.out.println();
}
}
} -
Hali,
mondjuk én első körben nem egyből egy random mátrixszal indítanék, hanem egy kicsit ellenőrzöttebb körülmények között tesztelném a cuccot. Pl. egy ilyennel:
1 1 1 1 1
1 2 2 2 1
1 2 3 2 1
1 2 2 2 1
1 1 1 1 1És akkor debug módban szépen lépkedve kiderítheted, hogy az a baj, hogy először mindig felfelé próbálkozol kijutni, majd ha nem megy, akkor lefelé. Csakhogy a próbálkozásod előtt nem csekkolod, hogy egyáltalán érdemes-e (<x). Mindenképp megpróbálod, így visszajutunk egy korábbi állapotba, ahonnan nem sikerült felfelé kijutni, így azt megpróbálni sem lenne érdemes, de ő csakazértis újra felfelé próbál. Nem tud, ezért megint lefelé indul el. A lefele ágban először újra felfelé indulna, és... gondolom érted, hogy ez a végtelenségig tart, ide-oda pingpongozik a két sor egymással.
Egy ilyen térképpel például szépen működik a progi, mert mindig csak felfelé kell másznia:
1 1 1 1 1
1 2 2 2 1
1 3 3 3 1
1 4 4 4 1
1 5 5 5 1Rekurzív hívásnál nagyon fontos a sorrend, amint tudod, terminálni kell a folyamatot. Érdemes először ellenőrizni, hogy a szomszédos szám valóban jó irány-e, és csak akkor ráhívni rekurzívan, ha tényleg van esély a kijutásra.
----
Apró adalék, hogy egy kis emlékezet bevezetésével, drasztikusan gyorsítható a program. Ugyanis ha számon tartod (pl. egy kimeneti mátrixban), hogy adott cellából sikerült-e korábban kijutni, akkor nem kell újra és újra végigjátszani a teljes útvonal bejárást. -
Remek... letelt az időkorlát. -.-
Szóval azt még elfelejtettem, hogy ha Set-re váltasz, akkor a Point.equals mellett a Point.hashcode-ot is implementálnod kell. Az IDE elvégzi helyetted, de a lényeg:
A HashSet úgy működik, hogy a beletolt objektumra először hashcode-ot számol, ez csak egy szám. Ehhez a hashcode-hoz létrehoz egy izét, nevezzük vödörnek, és ebbe a vödörbe dobja bele az objektumodat.
Ha egy újabbat adnál hozzá, akkor arra is hashcode-ot számol, és csak az adott hashcode-hoz tartozó vödörrel foglalkozik, végigmászik a vödör tartalmán, az equals-szal csekkolja, hogy benne van-e már, és ha talált, akkor nem teszi bele újra.
Ha a hashcode számítást elcseszed, akkor előfordulhat olyan, hogy van 2 objektumod, ami az equals szerint azonos, de a hashcode szerint nem. Mindkettő bele fog kerülni a Set-be (!!), mert a másik az eltérő hashcode miatt másik vödörbe kerül. Ilyet sose csinálj.
Vagy például megváltozik az objektumod állapota (mondjuk most nem, mert minden final, de máskor, mással, másnál igen), és a megváltozott állapot miatt megváltozhat a hashcode is. Na az az objektumod, ha benne volt egy set-ben, akkor ott is marad, sose találod meg. Vicces dolgok ezek. 
Gondolhatnád, hogy akkor legyen a hashcode mindig 1, abból baj nem lehet. Jó gondolat, de lassú lesz, épp azért szegmentálunk sok kis vödörre relatíve kis számításigényű megoldásokkal, hogy csak egy kis vödör tartalmán kelljen végigsuhanni, gyorsan el lehet dönteni, hogy valami benne van-e abban a Set-ben avagy sem. -
Sziasztok!
Ismét segítségeteket kérném.
Van egy pont osztályom:
public class Point{
private int x;
private int y;
public Point(int x, int y){
this.x = x;
this.y= y;
}
public int getX(){
return this.x;
}
public int getY(){
return this.y;
}
public boolean equals(Object other){
Point otherPoint = (Point) other;
return getX() == otherPoint.getX() && getY() == otherPoint.getY();
}
public double getDistance(Point other){
return Math.sqrt( Math.pow(getX() - other.getX(), 2) + Math.pow(getY() - other.getY(), 2));
}
public String toString(){
return "(" + getX() +", " + getY() + ")";
}
}Van egy pontokból álló vonallánc osztályom:
import java.util.ArrayList;
public class PolyLine{
private ArrayList<Point> points = new ArrayList<Point>();
public PolyLine(ArrayList<Point> points){
this.points = points;
for (int i = 0; i < points.size()-1; i++){
if (!add(points.get(i))){
points.remove(i);
i--;
}
}
}
public ArrayList<Point> getPoints(){
return points;
}
public boolean equals(Object other){
return points.equals(other);
}
public boolean add(Point p){
int pos = points.indexOf(p);
return pos != -1 && !points.get(pos+1).equals(p);
}
public String toString(){
String a = "[";
String b = "" ;
for (int i = 0; i < points.size()-1; i++){
b = b + points.get(i).toString()+ ", ";
}
String c = points.get(points.size()-1).toString() + "]";
return a + b + c;
}
}A baj az, hogy a két vonallánc összehasonlításánál az equals false-t dob, amikor azok megegyeznek. Az ismétlődések nem számítanak, azt a vonallánc constructorja kiszedi. A fejlécek fixek, azokat nem lehet változtatni. A sejtesem az, hogy point osztály equals metódusával számol és nem a beépített arraylistessel.
Itt hozza a teszt:
import java.util.ArrayList;
public class Bsp10{
public static void main(String[] args){
ArrayList<Point> points = new ArrayList<>();
points.add(new Point(292, -457));
points.add(new Point(292, -457));
points.add(new Point(292, -457));
points.add(new Point(17, -277));
points.add(new Point(-942, -103));
points.add(new Point(-557, -18));
PolyLine polyLine = new PolyLine(points);
ArrayList<Point> points2 = new ArrayList<>();
points2.add(new Point(292, -457));
points2.add(new Point(17, -277));
points2.add(new Point(-942, -103));
points2.add(new Point(-557, -18));
PolyLine polyLine2 = new PolyLine(points2);
System.out.println(polyLine);
System.out.println(polyLine2);
System.out.println(polyLine.equals(polyLine2));
}
}Köszi előre is!
-
én három hibát találtam:
- egy for ciklusban pontosvessző helyett sima vesszőt használtál
- a restaurants tömbneved végéről több helyen lehagytad a záró s-t
- w nem int tipusu, hanem RestaurantÚgyúgy! Thxxxxxxxxxxx!
Első kettő nekem is megvolt. A harmadikra valami bonyolult ötletem lett volna..
Jelentem Uraim működik!
Na jön a második rész....
-
#74220800
törölt tag
Sortolást List-el és Comparatorral.
-
#74220800
törölt tag
Hi!
Segítségeteket szeretnem kerni. Ismét egy rookie feladattal fárasztanálak benneteket
. Osztálytömb lenne a téma, kicsit belezavarodtam.
A lényeg röviden. Egy külön osztályban le kellett kepézni az éttermeket nevük, és kapacitásuk (tömbben asztalonként) szerint. Továbbá egy metódussal összesíteni az elérhető helyek számat, valamint egy másikkal stringbe rakni az eredményt.Nálam eddig ez így nézne ki:
public class Restaurant{
private int[] a;
private String e;
public Restaurant (String name, int[] seats){
e = name;
a = seats;
}
public int getTotalSeats (){
int x = 0;
for (int i = 0, i < a.length, i++){
x = x + a[i];
}
return x;
}
public String toString (){
String text;
text = e + ": " + getTotalSeats() + " Places";
return text;
}
}A követekéző lepésben a nyolcas sort metódusával összkapacitás alapján, csökkenő sorrendbe kéne őket rendezni.
Ha minden passzolna, akkor a feladat által megadott főmetódus kidobna az eredményt.
public class nyolcas{
public static void sort (Restaurant[] restaurants){
int max, w;
for (int i = 0; i < restaurants.length - 1; i++){
max = i;
for (int j = i+1; j < restaurants.length; j++){
if (restaurant[j].getTotalSeats() > restaurant[max].getTotalSeats())
max = j;
}
w = restaurants[max];
restaurants[max] = restaurants[i];
restaurants[i]= w;
}
}
public static void main(String[] args){
Restaurant r1 = new Restaurant ("A", new int[] {4, 10, 5, 6, 4});
Restaurant[] restaurants =
{ r1,
new Restaurant ("B", new int[] {5, 3, 1}),
new Restaurant ("C", new int[] {6, 4, 2}),
new Restaurant ("D", new int[] {7, 5, 3})
};
sort (restaurants);
for (Restaurant r: restaurants)
System.out.println (r);
}
}Sajnos nem eszi meg, pls help.
-
#74220800
törölt tag
Pontosan mi a kerdesed?
Hi!
Házi feladat része lenne.
Röviden:
Van egy "public static boolean[] firstPrimes(int n)" metódusom amely visszaad egy array-t, hogy [0 n] melyik prímszám. pl: {false, false, true, true, false, true, false, true}.
Köv lepésben a "public static int printFirstPrimes(boolean[] firstPrimes)" metódussal az előző metódus segítségével meg kéne számolni hány prímszám, melyek ezek és ki is kéne ezeket az eredményeket íratni.
Elképzelésem van, persze nyilván sz@r, mint mindig
:public static int printFirstPrimes(boolean[] firstPrimes){
int j=0;
for (int i = 0; i < firstPrimes.length; i++) {
if (firstPrimes==true)
j++;
}
int[] b = new int[j];
for (int w = 0; w < b.length; w++){
if (firstPrimes[w]==true){
b[w]=w;
System.out.print(b[w] + " ");
}
}
System.out.print(j);
return j;
}
Zavar hogy int-es a metódus és nem void-os, és így nem tudom hogy lehet e vele egyáltalán kiíratni az eredményt.
-
A tomb valtozojat deklaraltad, de a tombot nem hoztad letre. Igy aztan az elemeire se tudsz hivatkozni (se jobbertekkent, se balertekkent amugy).
double[] xo = new double[(r-l)*10+1];
Muszaj igy, mert ott egesz tipusu kifejezes kell, a 10-zel szorzassal nem lepsz ki belole, ellenben a 0.1-gyel osztassal mar igen...
Ja es ugyel<=rellenorzese utan csak mindez, ha nem akarsz meglepeteseket.
Új hozzászólás Aktív témák
A topicot kiemeltem. Valaki nem akar egy nyitó hsz-t írni?:))
- ASUS TUF Gaming F16 Laptop! i7-14650HX / RTX 5060 / 16GB DDR5 / 1TB NVMe! BeszámítOK
- Dell XPS 15 9500 - 15,6" hibás kijelző, i7 10750H, 8GB RAM, Nvidia GTX 1650 Ti 4GB VGA
- HIBÁTLAN iPhone 13 128GB Midnight -2 ÉV GARANCIA - Kártyafüggetlen, MS5479
- Apple iPhone 13 128GB, Kártyafüggetlen, 1 Év Garanciával
- Bomba ár! Lenovo ThinkPad T410 - i5-1GEN I 4GB I 250GB I DVDRW I 14,1" WXGA I Cam I Garancia!
Állásajánlatok
Cég: Laptopműhely Bt.
Város: Budapest