Abschlussprüfung GA1 Winter 2014/15 FIAE

[Martago]

Ich habe ein Problem mit den Lösungen von der IHK zum Handlungsschritt 3 im Winter 2014/15 Fachqualifikation Anwendungsentwicklung.

Grob die Aufgabenstellung:

An die Methode prozente() wird ein zweidimensionaler Array einkommen_miete übermittelt.

Beispiel für einkommen_miete:

4200 ________1200

900________ 340

1800________ 600

3600________ 1100

2700________ 800

5900________ 1300

.........

Mit der zu entwickeltem Methode prozente() sollen auf Basis diese Arrays

- Einkommensgruppen gebildet werden

- und je Einkommensgruppe der prozentuale Anteil der Miete am Gruppeneinkommen ermittelt werden.

Die gewünschte Anzahl Einkommensgruppen und deren Staffelung in EUR werden der Methode als Parameter anzahlGruppen und staffelung übergeben. Das folgende Beispiel zeigt die zuordnung von Einkommen zu Einkommensgruppen. Übergebene Parameter: anzahlGruppen = 5 und staffelung = 1000.

Einkommen Rechnung zur Ermittlung der Einkommensgruppe Zuordnung zu Einkommensgruppe

900 ________________ 900 / 1000 = 0,9 ________________ 0

1800 ________________ 1800/1000 = 1,8 ________________ 1

2700 ________________ 2700/1000 = 2,7 ________________ 2

3600 ________________ 3600/1000 = 3,6 ________________ 3

4200 ________________ 4200/1000 = 4,2 ________________ 4

5900 ________________ 5900/1000 = 5,9 ________________ 5

Nach der Gruppierung der Daten aus dem Array einkommen_miete sollen in der Methode prozente() die Daten so zusammengefasst werden, dass für jede Einkommensgruppe angeben wird, wie viel Prozent vom Haushaltseinkommen diese für Miete ausgibt. Die Prozentwerte sollen im eindimensionalen Array prozente ausgegeben werden, siehe folgendes Beispiel:

Einkommensgruppe Prozentualer Anteil

0 ________________ 38

1 ________________ 33

2 ________________ 30

3 ________________ 31

4 ________________ 25

#################################################################################################

Die IHK Lösung kurz zusammengefasst:

Es werden 3 eindimensionale Arrays initialisiert (prozente, summeEinkommen, summeMiete)

Anschließend wird eine for schleife durchlaufen. (Solange i bis anzahlGruppen - 1)

In dieser Schleife wird mit den Arrays so gearbeitet:

gruppe = einkommenMiete[0] / staffelung

An diesem Beispiel ist zu erkennen, dass laut Aufgabenstellung unendlich viele Einkommen/Miete gesendet werden können. Allerdings kann die Methode nur so viele Einkommen verarbeiten so viele es auch Gruppen gibt. Noch schlimmer ist es, wenn es weniger Einkommen/Miete gibt als Gruppen hageln Array IndeyOutOfBoundsExceptions.

#################################################################################################

Meine "nicht wirklich schöne" Lösung ist diese:

public class Main {


public static void main(String[] args) {

double [][] income_rent = new double [9][2];

income_rent[0][0] = 4200;

income_rent[0][1] = 1200;

income_rent[1][0] = 900;

income_rent[1][1] = 340;

income_rent[2][0] = 1800;

income_rent[2][1] = 600;

income_rent[3][0] = 3600;

income_rent[3][1] = 1100;

income_rent[4][0] = 2700;

income_rent[4][1] = 800;

income_rent[5][0] = 5900;

income_rent[5][1] = 1300;

income_rent[6][0] = 5900;

income_rent[6][1] = 1300;

income_rent[7][0] = 5900;

income_rent[7][1] = 1300;

income_rent[8][0] = 5900;

income_rent[8][1] = 1300;


int[] values = prozente(income_rent, 5, 1000);

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

System.out.println("Group: " + i + " %:" + values[i]);

}

}


private static int[] prozente(double[][] income_rent, int anzahlGruppe,

double staffelung) {

double group_values[][][] = new double[anzahlGruppe][income_rent.length][2];

int[] back_value = new int[anzahlGruppe];


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

// calc group

int group = (int) ((int) income_rent[i][0] / staffelung);

if (group > anzahlGruppe-1) group = anzahlGruppe - 1;


// insert values to the groups

group_values[group][i][0] = income_rent[i][0];

group_values[group][i][1] = income_rent[i][1];

}


// run through all groups

for (int i = 0; i < anzahlGruppe; i++) {

double array_income = 0, array_rent = 0;


// get the income and rent from the group

for (int incrent = 0; incrent < income_rent.length; incrent++) {

if (group_values[i][incrent][0] != 0) {

array_income += group_values[i][incrent][0];

array_rent += group_values[i][incrent][1];

}

}


// calc the %

double pro = 100 / array_income * array_rent;

pro = Math.round(pro);

back_value[i] = (int) pro;

}


return back_value;

}

}  

##############################################################################################

Nach meinen bisherigen Wissen, würde ich diese Aufgabe in der Prüfung streichen, da diese für mich deutlich zulange dauert.

Habt Ihr ein paar Tipps für mich, wie man solche Aufgaben in der richtigen Zeit lösen kann?

Seht Ihr Probleme an meiner Lösung?

Vielen Dank für eure Hilfe.

[orioon]

Ich will das jetzt nicht alles lesen aber:

Die IHK Musterlösung ist definitiv an mehreren Stellen falsch. Die äußere for schleife bezieht sich nicht auf die Anzahl der Elemente, das kann gar nicht funktionieren.

Der Funktionskopf ist auch schon falsch, da werden Parameter angenommen die nicht in der Aufgabenstellung auftauchen (irgendwas mit dem Mietanteil war das).

Habe mit einem Bekannten Ausbilder länger über die Aufgabe nachgedacht und der Ansatz der Musterlösung ist wirklich gut (wenn sie denn korrekt wäre).

Mein Tipp:

Mach dich nicht all zu sehr verrückt ob der Code wirklich funktioniert, versuche lieber die notwendigen Schritte gut darzustellen.

[Martago]

@orioon

Ich kann leider nicht nachvollziehen, dass der Ansatz gut ist, wenn dieser falsch ist.

Zu deinem Tipp:

Der Quellcode funktioniert, da ich diesen mit einem Compiler programmiert habe und daher konnte ich das Endergebnis auch mehrmals testen.

[Habaracka]

Bei der IHK Lösung sollte eigentlich nur die Bedingung für die for-Schleife nicht passen. Die muss man einfach ersetzen mit "i < einkommen_miete.Zeilenlaenge".

Meine lauffähige Lösung in Java:

    double[][] einkommen_miete = new double[][]{

        {4200, 1200},

        {900,340},

        {1800,600},

        {3600,1100},

        {2700,800},

        {5900,1300},

    };


    int anzahlGruppen = 5;

    int staffelung = 1000;


    double[] prozente = new double[anzahlGruppen];

    double[][] zuordnung = new double[anzahlGruppen][2];


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

    {

        double einkommen = einkommen_miete[i][0];

        double miete = einkommen_miete[i][1];

        int gruppe = (int)(einkommen / staffelung);

        if (gruppe >= anzahlGruppen - 1)

        {

            gruppe = anzahlGruppen - 1;

        }

        zuordnung[gruppe][0] += einkommen;

        zuordnung[gruppe][1] += miete;

    }


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

    {

        prozente[i] = Math.round(100 / zuordnung[i][0] * zuordnung[i][1]);

    }

Bei den letzten Prüfungen "musste" man immer eine Programmieraufgabe streichen, weil entweder zu lang und unklar oder zu kompliziert war. Vielleicht ist es diesmal auch wieder so.

Mein Tipp: Erst alle anderen machen und dann die 2 Programmieraufgaben anschauen. Die lauernden Probleme sind so schnell nicht zu erkennen und am Ende kann man die komplette restliche Zeit nutzen.

Bearbeitet 23. April 2015 von Habaracka

[Martago]

@Habaracka Jetzt fällt mich erst auf wie "dumm" ich war.

Vielen Dank für deine Hilfe.

Dein Tipp werde ich berücksichtigen, vielen Dank.

[montymotz]

Hier noch meine lösung in PHP im Anhang findet ihr die Lösung zum Testen als .php Datei mit Erläuterungen:

 

<?php
/**
 * Created by sehr Stürmisches PHP :-p
 * User: montymotz
 * Date: 07.11.2015
 * Time: 14:31
*/

error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);

$einkommen = array(
        "4200" => "1200",
        "900" => "340",
        "1800" => "600",
        "3600" => "1100",
        "2700" => "800",
        "5900" => "1300");

function gruppieren($anzGrp, $staffelung)
{
    global $einkommen;

    ksort($einkommen);

    $zga = array();

    foreach ($einkommen as $k => $v){

        $faktor = $k / $staffelung;
        $intWert = intval($faktor);
        if ($intWert >= $anzGrp) {      
            $gruppe = $anzGrp-1;
        } else {
            $gruppe = $intWert;
        }
        array_push($zga, array($gruppe, $k, $v));
    }

    return $zga;
}

function summieren($anzGrp, $staffelung)
{

    $gruppen = gruppieren($anzGrp, $staffelung);

    $summe = array();                                   

    for ($i = 0; $i < $anzGrp; $i++) {                  
        $einkommen_summe = 0;
        $miete_summe = 0;
        foreach ($gruppen as $t) {                      
            if ($t[0] == $i) {
                $einkommen_summe += $t[1];              
                $miete_summe += $t[2];                 
            }
        }
        array_push($summe, array($i, $einkommen_summe, $miete_summe));      
    }
    return $summe; 
}

function prozente($anzGrp, $staffelung)
{
    $summe = summieren($anzGrp, $staffelung);       
    foreach ($summe as $t) {                      
        echo "| " .  $t[0] . " | " . round($t[2] / $t[1] * 100) . " |<br/>";        
    }
}

prozente(5, 1000);
?>

 

index.php

Bearbeitet 9. November 2015 von montymotz