Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

A felmentoBizonyitek metódusban a nyomozó kizár egy gyanút az egyik gyanúsított- ról,…

  1. User

    A felmentoBizonyitek metódusban a nyomozó kizár egy gyanút az egyik gyanúsított- ról, azaz törli a gyanusitottak tömbb®l a paraméterben kapott név egyik el®fordulását, amennyiben volt benne. A gyanúsítottak között egy név többször is el®fordulhat, azaz lehet ismétl®dés. Ilyen esetben a legutolsó el®fordulást törli a metódus, de ekkor is csak egy elemet töröl. A törlés során fontos, hogy a tömb mérete változik. Ezt úgy tudjuk elérni, hogy egy teljesen új tömböt hozunk létre (ami pontosan egy elemmel kevesebbet tárol), és ebbe másol- juk át a tömb kívánt tartalmát. Ezután ne felejtsük el a gyanusitottak tömböt erre az új tömbre állítani! A metódus true értékkel tér vissza, ha sikeres volt a törlés, false értékkel pedig ha nem volt a kapott névnek megfelel® elem.

    public boolean felmentoBizonyitek (String kit) {
        boolean torolt = false;
    
        String[] ujtomb = new String[gyanusitottak.length-1];
    
        for (int index = gyanusitottak.length-1; index >= 0; index--) {
            if (kit.equals(gyanusitottak[index])) { //1
                for (int i = 0; i < gyanusitottak.length; i++) { //0-2
                    if (i < index) {
                        ujtomb[i] = gyanusitottak[i];
                    } else if (i > index) {
                        ujtomb[i-1] = gyanusitottak[i];
                    }
                }
                gyanusitottak = ujtomb;
                torolt = true;
                break;
    
            }
        }
    
    
        if (torolt == true) {
            return true;
        } else {
            return false;
        }
    }
    

    Teszt: ✖ Sikertelen: felmentoBizonyitek (nem módosít, ha nincs ilyen nevű) (1.0 pont) - Ismeretlen hiba, oka: java.lang.NegativeArraySizeException: -1

  2. Assistant

    A felmentoBizonyitek metódusban van egy alapvető logikai hiba: az új tömb létrehozása a törlés előtt történik, és fix mérettel inicializálódik. Ez akkor is megtörténik, ha a keresett név nem szerepel a gyanúsítottak között, amely az alábbi problémát okozza:

    Ha a "gyanusitottak" tömbben nincs olyan elem, amely megegyezne a "kit" paraméter értékével, akkor a tömböt nem szükséges lecsökkenteni, és így az új tömb létrehozása negatív méretű tömböt eredményezhet. A NegativeArraySizeException kivétel arra utal, hogy a kódban megpróbálunk egy negatív méretű tömböt létrehozni, ami nem megengedett.

    Ezt a problémát úgy tudjuk orvosolni, hogy csak akkor hozzuk létre az új tömböt, ha megtaláljuk és töröljük a keresett nevet. Ekkor a tömb létrehozása pontosan egy elemmel kevesebbet fog tartalmazni, mint az eredeti tömb. A kód egy lehetséges javítása:

    public boolean felmentoBizonyitek(String kit) {
        boolean torolt = false;
        int torlesIndexe = -1;
    
        // Először megkeressük a törlendő elem indexét
        for (int index = gyanusitottak.length - 1; index >= 0; index--) {
            if (kit.equals(gyanusitottak[index])) {
                torlesIndexe = index;
                torolt = true;
                break;
            }
        }
    
        // Ha megtaláltuk az elemet, akkor létrehozunk egy új tömböt, és átmásoljuk az adatokat
        if (torolt) {
            String[] ujtomb = new String[gyanusitottak.length - 1];
    
            for (int i = 0; i < gyanusitottak.length; i++) {
                if (i < torlesIndexe) {
                    ujtomb[i] = gyanusitottak[i];
                } else if (i > torlesIndexe) {
                    ujtomb[i - 1] = gyanusitottak[i];
                }
            }
            gyanusitottak = ujtomb;
        }
    
        return torolt;
    }
    

    Ebben a változatban először megkeressük a törlendő elem indexét (a legutolsó előfordulását). Csak ha megtaláljuk, hozunk létre egy új, egy elemmel kisebb tömböt, amibe átmásoljuk az adatokat a törölt elem kihagyásával. Szükségtelen kétszer iterálni a tömbön belül; a kiírt példában csak egy ciklus szükséges, ami a törlési index alapján átmásolja az elemeket az új tömbbe. Végül az új tömböt hozzárendeljük a "gyanusitottak" változóhoz.

  3. User

    Így esetleg? public boolean felmentoBizonyitek (String kit) { boolean torolt = false;

        for (int index = gyanusitottak.length-1; index >= 0; index--) {
            if (kit.equals(gyanusitottak[index])) { //1
                String[] ujtomb = new String[gyanusitottak.length-1];
                for (int i = 0; i < gyanusitottak.length; i++) { //0-2
                    if (i < index) {
                        ujtomb[i] = gyanusitottak[i];
                    } else if (i > index) {
                        ujtomb[i-1] = gyanusitottak[i];
                    }
                }
                gyanusitottak = ujtomb;
                torolt = true;
                break;
    
            }
        }
    
    
        if (torolt == true) {
            return true;
        } else {
            return false;
        }
    }
    
    public void inditek () {
        if (gyanusitottak.length > 1) { //csak akkor kell pakolgatni, ha tobb mint 1 gyanusitott van
            String terhelt = gyanusitottak[0];
            int i;
            for (i = 0; i < gyanusitottak.length-1; i++) {
                gyanusitottak[i] = gyanusitottak[i+1];
            }
            gyanusitottak[i] = terhelt;
        }
    }
    
  4. Assistant

    Igen, a módosított felmentoBizonyitek metódusod mostmár megfelelően kezeli a törlést és az új tömb létrehozását is, csak akkor hozza létre az új tömböt, ha talált ilyen nevű gyanúsítottat a listában, és csak ebben az esetben törli azt. Ez elkerüli a NegativeArraySizeException kivételt, mivel a tömb létrehozása már csak akkor történik meg, ha valóban van törölnivaló elem.

    A metódus logikája is egyszerűsödött:

    1. Végigmegyünk a tömbön visszafele, hogy megtaláljuk a legutolsó előfordulást.
    2. Ha megtaláljuk az eltávolítandó nevet, akkor létrehozunk egy új tömböt, amely egyel kisebb, mint az eredeti.
    3. Átmásoljuk az elemeket az új tömbbe, kihagyva a törölni kívánt nevet.
    4. Az új tömböt beállítjuk a gyanusitottak tömbnek.
    5. torolt változó értékété true-ra állítjuk és kilépünk a ciklusból.
    6. A végén a torolt változó értéke alapján visszaadjuk a metódus eredményét.

    A boolean változók esetében közvetlenül is visszatérhetsz az értékükkel, így a végén a kód leegyszerűsödhet:

    return torolt;
    

    Helyett:

    if (torolt) {
        return true;
    } else {
        return false;
    }
    

    Az inditek metódusról nem kaptam teljes információt, de ez a metódus egy ciklikus eltolást (rotációt) valósíthat meg a tömbön, ahol az első elemet helyezi át a tömb végére. Az írt leírásod alapján ez a metódus is helyesen működik ahhoz a célhoz, amit leírtál. Bizonyosodj meg arról, hogy a gyanusitottak tömböt és a felmentoBizonyitek metódust egy közös osztályban, megfelelően inicializált tömbbel használod.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.