Üdv. Javaban hogy van a szétválogatás lekódolva?

nagyon egyszerű! gondolom 9-es vagy ott tanítják ezt.

először is mivel szétválogatásról van szó ezért pontosan akkora tömb kell, amennyi szám van. Tehát akkor egy megszámlálással kell kezdeni.

De előtte létrehozod a tömböt

int []BBe;

int []CBe;

Itt létrehoztál 2 egész számokat tartalmazó BBe és CBe tömböt.

akkor létrehozol 2 változót, amivel majd azt adod meg, hogy a tömbnek mekkora legyen a mérete.

int Bbe = 0;

int Cbe = 0;

ezután végigmégy az eredeti tömbön

for(int i = 0; i < tomb.length; i++)

{

if(tomb[i]%2 = 0)

{

Bbe++;

}

if (tomb[i]%2 != 0)

{

Cbe++;

}

}

itt megnézted, hogy miből mennyi van. EZután ezt beállítod mint a tömb mérete

Bbe = new int[Bbe]

Cbe = new Int[Cbe]

a tömb mérete megegyezik a változó méretével.

Nullázod a változókat!

Bbe = 0;

Cbe = 0;

Ezután végigmégy a tömbön és átrakod a másikba

for (int i = 0; i < tomb.length; i++)

{

if(tomb[i]%2 = 0)

{

Bbe[i] = tomb[i]

Bbe++;

}

if (tomb[i]%2 != 0)

{

Cbe[i] = tomb[i]

Cbe++;

}

}

a második for ciklusban azért kell növelni a változót, mert oda fogja rakni. Pl berakja a 0. indexú helyre a BBe tömbbe a számot, akkor utána már csak az első indexű helyre fogja tudni rakni, ezért kell megnövelni a változót. Persze előtte nullázni!

Felteszem, egész számokról van szó. Tessék, gondolom, úgyis kész megoldásért csorgatod itt a nyálad:

int[] A = {...};

//Mivel nem írtad, hogy B-nek és C-nek tömbnek kell lennie, így azok most listák lesznek:

List<Integer> B = new LinkedList<>();

List<Integer> C = new LinkedList<>();

//Most átnézzük az összes számot:

for (Integer Current: A) {

//Ha az aktuális szám páros, berakjuk B-be,

if (Current % 2 == 0) B.add(Current);

//Ha páratlan, akkor a C-be

else C.add(Current);

}

Jogos a kérdés, hogy a 0-val mit kezdjünk. Hát most páros lett.

A nulla páros szám, kivéve a rulettkeréken.

[link]

Tehát a % 2 == 0 valóban a páros számokra igaz.

Húha, nem gondoltam volna, hogy bárkiben is felmerül a kérdés, hogy a 0 páros-e vagy sem. És egy egész wikipedia szócikk szól róla...

Amúgy az első válaszban van jópár hiba:

1: Az egyenlőség vizsgálatot két egyenlőségjellel vizsgáljuk, tehát ez hibás: tomb[i]%2 = 0

2: ez nem hiba, de nagyon csúgya: Az 1-es pontban lévő feltételt vizsgálja, majd az ellentétét is, mért nem simán else?

3: a második for ciklusban a Bbe[i]-vel van a gond, egyrészt a tömb neve BBe (ez a létrehozásor is rossz), de a nagyobb hiba hogy az i. elemébe akarja rakni, igy túl fog indexelni, a Bbe. elemébe szerette volna rakni, gondolom. Ugyanez a C-vel is.

Nem kifejezetten bonyolult probléma, hiszen csak azt kell ellenőrizni, hogy mely számok oszthatóak kettővel.

Ha már másokkal szeretnéd megoldatni, próbálkozzunk meg egy olyan megoldással, amiből talán tanulhatsz is valamit. :)

˙˙˙˙List<Integer> odds = new ArrayList<>();

˙˙˙˙List<Integer> evens = new ArrayList<>();

˙˙˙˙for (Integer value : input) {

˙˙˙˙˙˙˙˙List<Integer> target = value % 2 == 0 ? evens : odds;

˙˙˙˙˙˙˙˙target.add(value);

˙˙˙˙}

˙˙˙˙int[] oddArray = odds.toArray(new int[odds.size()]);

˙˙˙˙int[] evenArray = evens.toArray(new int[evens.size()]);

Két számunkra kapóra jövő dolgot használunk ki a List típussal kapcsolatban:

- Dinamikus a mérete, így nem kell előre tudnunk, vagy kiszámolnunk, mekkora tömbökre lesz szükségünk

- A toArray metódus segítségével közvetlenül tömbbé konvertálhatóak

A for ciklusnál dönthetünk a hagyományos, indexelős for ciklus, vagy az iterátoros (for each) megoldás mellett.

Én az utóbbit választottam, mert tömörebb, olvashatóbb. Egyéb, ide nem tartozó sajátossága mellett idevágó hátránya, hogy az autoboxing miatt csakúgy röpködnek az objektumok, amelyek természetesen memóriát foglalnak, azonban mivel ez az adott feladatnál nem kritikus kérdés, így mindenképpen az olvashatóságot illik előnyben részesíteni.

Előre optimalizálni amúgy sem szabad, de kanyarodjunk vissza a témához!

A ciklusmag első sora inkább elegáns, mint jól olvasható, bár ez főleg megszokás kérdése.

A "feltétel ? akkor : egyébként" az úgynevezett ternary operátor (Van ennek magyar neve? Tán hármas operátor?).

Felfogható egy olyan, egy sorba tömörített if-else elágazásként, amelynek egy érték az eredménye, attól függően, hogy a megadott feltétel igaz-e, vagy hamis.

Ha a kérdőjel előtti feltétel igaz, akkor a kettőspont előtti, ha hamis akkor a kettőspont utáni érték lesz az eredmény.

A target nevű változó attól függően fog az odds (páratlanok) vagy evens (párosak) listára mutatni, hogy a "value % 2 == 0" igaz-e, avagy hamis.

Mintha lenne két szatyrod, és valamilyen feltételtől függően vagy az egyiket, vagy a másikat vennéd a kezedbe. A következő sorban bármelyik szatyor is legyen a kezedben, abba beleteszed a számodat.

Természetesen leírható a ciklusmag így is (ahogyan az a #2 kollégánál szépen látható is):

˙˙˙˙˙˙˙˙if (value % 2 == 0) {

˙˙˙˙˙˙˙˙˙˙˙˙evens.add(value);

˙˙˙˙˙˙˙˙} else {

˙˙˙˙˙˙˙˙˙˙˙˙odds.add(value);

˙˙˙˙˙˙˙˙}

Kezdetnek ez olvashatóbb, ugyanakkor egy picivel több kódból is áll, és némi duplikációt is tartalmaz (vegyük észre, hogy mindkét ágban ugyanazt csináljuk, vagyis eltesszük a számot egy listába).

Tehát kiválasztjuk, melyik listába való az aktuális szám, majd beletesszük abba.

Végezetül mindkét listát tömbbé konvertáljuk a már említett toArray metódussal.

Itt is kétféle választásunk van. A paraméter nélküli metódus szebb, olvashatóbb, azonban Object[] a visszatérési értéke, így ezt nem szeretjük.

A másiknak a típus miatt meg kell adnunk egy tömböt paraméterként, amit ilyen csúnyácskán tudunk kivitelezni.

Két dolgot látok még érdemesnek megemlíteni:

Az első, hogy az if-else blokkok zárójelezését (tehát a { és } jeleket), illetve az újsort és indentációt elhagyni nem szabad.

Bár elsőre ártatlannak tűnő dolog, valójában azonban idegtépő galibák forrásává tud válni.

Részleteiben ebbe most nem megyek bele, fogadjuk el, hogy érdemes tartózkodni az effajta "lustaságtól".

A második, hogy a feltételeket illik dedikált metódusokban elhelyezni és beszédes névvel hivatkozni rájuk.

Jelen esetben a "value % 2 == 0" kifejezést illeti meg a saját metódus, valahogyan így:

˙˙˙˙private boolean isEven(Integer number) {

˙˙˙˙˙˙˙˙return value % 2 == 0;

˙˙˙˙}

Ekkor a ciklusunk a következőképpen alakul:

˙˙˙˙for (Integer value : input) {

˙˙˙˙˙˙˙˙List<Integer> target = isEven(value) ? evens : odds;

˙˙˙˙˙˙˙˙target.add(value);

˙˙˙˙}

Így máris egészen olvasható :)

Az isEven metódus bemenő paramétereként azért használunk Integert (ami ugye objektum, szemben az int primitív típussal), hogy ne tornáztassuk feleslegesen az autoboxingot/-unboxingot.

Teljesértékű alkalmazásként a dolog persze megintcsak más világ, de az már egy másik lapra tartozik.