- Hamarosan megkezdődik a nubia 2,8K-s táblagépének szállítása
- Barátokká váltak az eddig rivális AI-óriások
- ASUS blog: Ideális olcsó utazós gép lett az új Vivobook S14
- Az Aura Displays hordozható monitorhármasa jól felturbózhatja a produktivitást
- Dual Mode-os IPS monitorral adott magáról életjelet a Gigabyte
- HiFi műszaki szemmel - sztereó hangrendszerek
- AMD Ryzen 9 / 7 / 5 9***(X) "Zen 5" (AM5)
- Steam Deck
- Hobby elektronika
- Nem indul és mi a baja a gépemnek topik
- NVIDIA GeForce RTX 4080 /4080S / 4090 (AD103 / 102)
- Kezdő fotósok digitális fényképei
- Intel Core i5 / i7 / i9 "Alder Lake-Raptor Lake/Refresh" (LGA1700)
- Radeon RX 9060 XT: Ezt aztán jól meghúzták
- Apple MacBook
Új hozzászólás Aktív témák
-
Lortech
addikt
válasz
#74220800
#9392
üzenetére
Kell nekik egy közös ős, interface vagy base class, pl.
public interface Queue<E> {...}
aztán
public class QueueArray<E> implements Queue<E> {}
végül
public static <E> long counter(Queue<E> c, int r) {Persze nem írtad, hogy néz ki az általad kreált két class és hol lenne ez a metódus, illetve nem tudni pontosan mit akarsz ezzel, de gyanús, hogy érdemesebb lenne eleve az interface-be vagy base-be tenni ezt a countert, példány szinten.
-
axioma
veterán
válasz
#74220800
#9327
üzenetére
Argh, a megvan-os hsz-edet figyelmetlenul olvastam, azert benne hagyom mert ha ott insert-alsz, akkor talalsz me'g ebben hasznos infot.
En azt nem ertem, hogy miert veszed kulon a torlest es a heapify-t... torolsz az _elejerol_ (ami implementaciofuggo, de a vegerol torles csak olcsobb vagy ugyanannyi lehet, mint az elejerol), holott neked az elejen kell a hely, az utolso elemet kene csak odahelyezni es lekuldeni.
Bocs, java kodban nincs epp keznel, de pythonban ugyanez a kivetel (a tombindexeles ellenere az egy lista, a pop() meg az utolso elemet tavolitja el es adja ertekul):print mylist[0]
if cou==1: # itt van az aktualis meret
mylist=[]
cou=0
else:
act=mylist.pop()
cou-=1
tmp=0
while (tmp*2+1<cou and mylist[tmp*2+1]>act) or (tmp*2+2<cou and mylist[tmp*2+2]>act):
if tmp*2+2==cou or mylist[tmp*2+1]>mylist[tmp*2+2]:
mylist[tmp]=mylist[tmp*2+1]
tmp=tmp*2+1
else:
mylist[tmp]=mylist[tmp*2+2]
tmp=tmp*2+2
mylist[tmp]=actEgyebkent most hogy nezem a kodod, pont ez a baj! Hiszen az eltavolitas utan lesz egy olyan listad, ami az uj index miatt mar nem is heap! Ez szerintem egy erosen kerulendo koztes allapotkent is... Be kene elore szurni magat az utolso elemet, es arra hivni a heapify-t, de akkor mar egyszerubb ez az on-the-fly modszer (amig nem teszed be, addig csak orzod hasonlitasra, majd a vegleges helyen adod ertekul).
-
axioma
veterán
válasz
#74220800
#9325
üzenetére
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. -
Sirpi
senior tag
-
disy68
aktív tag
válasz
#74220800
#9284
üzenetére
Java 8 alatt van lehetőség metódus referenciát átadni. Akár az alábbihoz hasonlóan is elindulhatsz:
public class MethodRuntimeChecker {
public static void main(String[] args) {
QuickSorter sorter = new QuickSorter();
int[] array = getNumbers(10_000);
System.out.println(mesureRunTimeNano(sorter::sort, array) + " ns");
System.out.println(mesureRunTimeMilli(sorter::sort, array) + " ms");
}
public static long mesureRunTimeNano(Function<int[], int[]> intSorter, int[] toBeSorted) {
long start = System.nanoTime();
intSorter.apply(toBeSorted);
return System.nanoTime() - start;
}
public static long mesureRunTimeMilli(Function<int[], int[]> intSorter, int[] toBeSorted) {
long start = System.currentTimeMillis();
intSorter.apply(toBeSorted);
return System.currentTimeMillis() - start;
}
private static int[] getNumbers(int count) {
int[] numbers = new int[count];
Random random = new Random();
for (int i = 0; i < count; i++) {
numbers[i] = random.nextInt(count);
}
return numbers;
}
} -
#74220800
törölt tag
válasz
#74220800
#9247
üzenetére
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;
}
} -
Szmeby
tag
válasz
#74220800
#9124
üzenetére
Szuper.
Jól gondolod, az && meg a || shortcut operátornak is hívja magát, ha a feltétel eleje önmagában is meghatározza a feltétel kimenetelét a többi része már fel sem hívódik."De miért nem megy úgy, ha előszór a rekurzív képletet hívom meg ..."
Azért mert a rekurzív hívásnak le kell futnia ahhoz, hogy a feltételben ki lehessen értékelni. De nem fut le. Belemegy a metódusba újra új paraméterekkel, majd azon belül is újra megint új paraméterekkel, és így tovább. A végtelen ciklus miatt csak befelé megy, sose jön ki onnan. Valaminek terminálnia kell, csak akkor jut vissza, akkor tudja azt mondani, hogy true vagy false, az if-ben akkor ki tud értékelődni, és lefutna a programod.
Nézd át újra a rekurzióról tanultakat. Vagy tényleg tegyél bele egy breakpointot, és - ha Eclipse-et használsz - nyomogasd az F5-öt a flow hívásnál. Ezzel belelép... megnézheted, miben változtak a paraméterek és hogy a hívás meddig jut el a metódusban, mielőtt újra ráhívna saját magára, F5. Nézd közben a stack-et is, minden egyes rekurzív hívásnál egy új sorral bővül.
Ha már érted, vedd ki a breakpointot és F8-cal engedd el, hadd teljesítse be a végzetét.
-
Szmeby
tag
válasz
#74220800
#9121
üzenetére
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. -
Szmeby
tag
válasz
#74220800
#9101
üzenetére
Nem egészen.
Van 2 PolyLine objektumod, amit a Bsp10-ben hozol létre polyLine és polyLine2 néven.
Fogod a polyLine nevűt, és ráhívsz az equals metódusára, paraméterként pedig átadod ugye a polyLine2-t.A történések ezután az equals-on belül zajlanak tovább. A korábban polyLine-nak nevezett objektumot az equals-ban a this kulcsszóval érheted el (amit többnyire nem kötelező kiírni, névütközés esetén viszont kénytelen az ember... na mindegy), míg a polyLine2 most már obj néven érhető el. A csavar ott van, hogy az equals szignatúrája csak Object típusú paramétert enged meg, ezért az obj paramétert kénytelen vagy Object típussal definiálni, erről viszont a java már nem tudja, hogy az valójában egy PolyLine objektum, így a spéci metódusaira sem tud ráhívni, és a field-jeit sem látja.
Úgyhogy castolunk, megmondjuk őnagyságának, hogy ez bizony egy PolyLine:
PolyLine other = (PolyLine) obj;
Megjegyzem, most ez így működik, de ha megpróbálsz egy nem PolyLine objektumot betolni, szétszakad az egész, tehát érdemes az equals-ban előbb megbizonyosodni arról, hogy valóban PolyLine-e (getClass() metódus felhívásával, instanceof-fal).Ezekután az other változóról már tudjauk, hogy PolyLine, elérjük minden metódusát és field-jét, például a hasában lévő points listát is. Egy Object esetén ezt nem tudod megtenni. És ezt a listát össze tudjuk hasonlítani a this objektumunk points listájával.
return this.points.equals(other.points);
Rövidebben:return points.equals(other.points);Tehát listát hasonlítunk listával, ezért működik.
Ez nem castolás, csak meghivatkozzuk az objektum egy field-jét.
Castolásnál a változónév elé zárójelben megadjuk azt a típust, amire castolni akarunk, és ezzel aztán azt kezdünk, amit akarunk. Az "other.points" nem tartalmaz semmilyen zárójelet meg típust, ez csak ráhív a points nevű mezőre az other objektumban.A castolás elhiteti a jvm-mel, hogy az adott objektum valójában egy másik típusú objektum. Itt nem változtatunk a típuson, a this és az other továbbra is PolyLine típusú, és mindkettő hasában van 1-1 lista (points néven), amit felhasználunk az egyezőség megállapításához. A points.equals() tehát az ArrayList-en található equals metódus.
Ha a this-t és az other-t hasonlítanád itt össze egymással, az ugyanabba az equals metódusba hívna bele (rekurzió) újra és újra, amiben eleve vagy, és addig pörögne, amíg el nem fogy a stack, majd lehal az egész. Próbáld ki.
És kérdezz bátran.
-
Szmeby
tag
válasz
#74220800
#9096
üzenetére
Ezért ne kövesd el te azt a hibát, amit a java megalkotói, hogy túl általános típust használsz.
Jó, tudom, csak kompatibilitás, de akkoris.Szóval a probléma a PolyLine.equals-ban van. Mivel a szignatúrája szerint Objectet vár, az ember bármit beadhat. És hidd el, be is fog. Amin aztán az egész cucc megfekszik (pl. ClassCastException-nel), ha nem figyelsz. Rosszabb esetben - mint most is - működik tovább hibásan.
Javaslom, minden equals metódusodban ellenőrizni a bejövő paraméter típusát. Ha nem jó típus, akkor false, ha jó típus, akkor pedig tessék castolni, és aztán hasonlítgatni. Könnyebben kibukik, hogy a beadott PolyLine nem is ArrayList, amivel hasonlítani akarod.
Egyébként az equals, hashcode metódusokat egy IDE szépen ki is generálja neked, van rá menüpont.Szóval listát a listával:
public boolean equals(Object obj){
if (obj == this) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
PolyLine other = (PolyLine) obj;
return points.equals(other.points);
}Ha nem kellenek az ismétlődések, miért nem egy rendezett Setet használsz erre a célra? LinkedHashSet, vagy valami ilyesmi. Ő magától megcsinálja.
Pár megjegyzés:
- Osztályon belül felesleges gettereket használnod, simán lehet hivatkozni a field-ekre, pl.:return Math.sqrt(Math.pow(this.x - other.x, 2) + Math.pow(this.y - other.y, 2));- Ha az objektum állapota nem változhat, akkor érdemes a field-eket final-ra állítani, így még véletlenül sem fogod tudni tönkretenni az objektumaidat. Továbbá egy ilyen tipikus value object esetén én még a getterek elhagyását is megkockáztatnám, valahogy így:
public class Point{
public final int x;
public final int y;
public Point(int x, int y){
this.x = x;
this.y= y;
}
public boolean equals(Object other){
// ...
}
public double getDistance(Point other){
// ...
}
public String toString(){
// ...
}
}- Ne félj interfészt használni, ahol lehet, könnyebben cserélgetheted majd mögötte az implementációt. Ha nem akarod cserélgetni, akkor sem árt, mert idővel rááll a kezed, és nem kell folyton törnöd az APIt egy kis módosítás miatt.
Erre gondolok:private ArrayList<Point> points = new ArrayList<Point>();
// helyett
private List<Point> points = new ArrayList<Point>();
// esetleg (attól függ, milyen funkcionalitást vársz el tőle, legyen-e rendezett, stb)
private Collection<Point> points = new ArrayList<Point>();- Ciklusban Stringeket konkatenálni + jellel nem szép dolog, brutálisan pazarló. Minden egyes konkatenáció egy újabb és egy újabb Stringet hoz létre, amit aztán a következő körben el is dob, mert csak átmenetileg volt rá szükség. StringBuilder javallott és annak append metódusa. Vaaagy használod a listák toString metódusát, mert van.
-
-
-
Szmeby
tag
válasz
#74220800
#8886
üzenetére
Igen, lehet. Bármit bárhol kiírhatsz a konzolra. Még a metódus neve is azt sugallja, hogy írni fog a konzolra. Meg ez csak egy vacak iskolai feladat. Ha így kérik, hát így kérik. Adj neki!
Az, hogy mivel tér vissza, int, void, kiskutya, ettől teljesen független. Nem fáj neki az a print.Megjegyzem, kicsit zavaró lehet az utolsó szám (j), mivel az nem egy prím, hanem egy darabszám lesz. A kiírásnál én azt jobban elkülöníteném. Akár mondjuk egy külön sorba írva (println), vagy valami extra felvezető szöveggel. Sőt, mivel a metódus ezt a számot ki is adja magából, talán a hívó megoldja a kiírást, nem? Persze ha a feladat kifejezetten azt kéri, hogy a prímek után írd, akkor nincs mese.
Továbbá egy apróság:
Ha olyat látsz, hogyif (valami == true) {
akkor az pontosan ugyanazt jelenti, hogyif (valami) {
mivel a 'valami' egy boolean, és az utóbbi a szebb megoldás.Ugyanez tagadással is:
if (valami == false) {
szépenif (!valami) {A 'valami' tehát egy boolean változó neve, és ezeket úgy szokás elnevezni, hogy egy eldöntendő (igen/nem) kérdést takarjon. Például: isValid vagy hasValue, stb, akkor a teljes feltétellel kiolvasva értelmes mondatot kapsz: if (isValid), vagy if (!hasValue). Jobb nem lesz tőle a kód csak szebb. És ha az olvasható változatot szokod meg, az csak a javadra válik később. Meg a leendő kollégáidnak is több hajszála marad.
-
#8887
Chesterfield
őstag
#74220800
#8886
-
#74220800
törölt tag
válasz
#74220800
#8885
üzenetére
Bocs előzőt kérlek töröljetek!
Tehát egyszerűen akkor?:
public static int printFirstPrimes(boolean[] firstPrimes){
int j=0;
for (int i = 0; i < firstPrimes.length; i++) {
if (firstPrimes[i]==true){
j++;
System.out.print(i + " ");
}
}
System.out.print(j);
return j;
}A feladat kiírás szerint pontosan ezzel a metódussal "public static int printFirstPrimes(boolean[] firstPrimes)" kell a prímszámokat megszámolni, ill. kiadni. A bajom az hogy, elméletileg ez egy int értékel tér vissza, így nem tudom hogy lehet-e kiirtásra is használni.
-
ToMmY_hun
senior tag
válasz
#74220800
#8883
üzenetére
1. Formázd a kódot, ez így nagyon hányingerkeltő. Van itt is programkód kompatibilis tag, de javaslom a pastebin vagy egyéb weboldal használatát.
2. Le kell mentened a prím ellenőrzés eredményét? Ezt egy külön tömbben kell megtenned? Ha ezt explicit módon nem említi a feladat, akkor a megközelítésed eléggé erőforrás pazarló. (amennyiben kéri és ezt ilyen módon teszi, akkor szólj az oktatónak hogy ne tanítson ilyen butaságokra)
3. Használj ranged for ciklust, ha nem kell az indexet felhasználnod.
4. A sima array helyett használj dinamikus tömböt, például ArrayList-et, és megspórolhatod vele a második for ciklust.
5. Több értéket akarsz kiírni, miért egy int-tel térsz vissza? Számomra eléggé katyvasz a feladat leírás. Le tudod írni az eredetit?
Egyébként a tömb indexelést alapból felejtsd el. Akkor kell használni, ha nincs más megoldás, minden egyéb esetben kerülendő.
-
-
axioma
veterán
válasz
#74220800
#8800
üzenetére
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
Hirdetés
A topicot kiemeltem. Valaki nem akar egy nyitó hsz-t írni?:))
- Lakáshitel, lakásvásárlás
- Mobil flották
- Tesla topik
- Parci: Milyen mosógépet vegyek?
- HiFi műszaki szemmel - sztereó hangrendszerek
- PROHARDVER! feedback: bugok, problémák, ötletek
- D1Rect: Nagy "hülyétkapokazapróktól" topik
- Horizon Forbidden West
- Kerékpárosok, bringások ide!
- AMD Ryzen 9 / 7 / 5 9***(X) "Zen 5" (AM5)
- További aktív témák...
- új, bontatlan, iPhone 16E gyárilag kártya-független, apple világgaranciával
- Üzletből, garanciával, Macbook Pro Retina 16" 2019, Gray i9 64GB RAM 1TB SSD Radeon Pro 5500M
- Üzletből, garanciával, Macbook Pro Retina 16" 2019, Gray i9 64GB RAM 2TB SSD Radeon Pro 5600M 8GB
- MacBook Pro 14" M1 MAX - 32GB / 1TB (2021) - 1 év garancia
- MSI RTX 4070 SUPER 12GB GAMING X SLIM WHITE - 20 hónap garancia
- Azonnali készpénzes Microsoft XBOX Series S és Series X felvásárlás személyesen/csomagküldéssel
- Telefon felvásárlás!! iPhone X/iPhone Xs/iPhone XR/iPhone Xs Max
- Bomba ár! HP ZBook Studio G5 - XEON I 32GB I 512SSD I Nvidia I 15,6" 4K DreamColor I Cam I W11 I Gar
- Xbox Game Pass Ultimate kedvező áron, egyenesen a Microsoft-tól! - AUTOMATA BOLT
- KIÁRUSÍTÁS - REFURBISHED és ÚJ - Lenovo ThinkPad Ultra Docking Station (40AJ)
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: PC Trade Systems Kft.
Város: Szeged