Zum Inhalt springen

Empfohlene Beiträge

Geschrieben

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.

Geschrieben

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.

Geschrieben

@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.

Geschrieben (bearbeitet)

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 von Habaracka
  • 6 Monate später...
Geschrieben (bearbeitet)

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 von montymotz

Dein Kommentar

Du kannst jetzt schreiben und Dich später registrieren. Wenn Du ein Konto hast, melde Dich jetzt an, um unter Deinem Benutzernamen zu schreiben.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung wiederherstellen

  Nur 75 Emojis sind erlaubt.

×   Dein Link wurde automatisch eingebettet.   Einbetten rückgängig machen und als Link darstellen

×   Dein vorheriger Inhalt wurde wiederhergestellt.   Editor leeren

×   Du kannst Bilder nicht direkt einfügen. Lade Bilder hoch oder lade sie von einer URL.

Fachinformatiker.de, 2024 by SE Internet Services

fidelogo_small.png

Schicke uns eine Nachricht!

Fachinformatiker.de ist die größte IT-Community
rund um Ausbildung, Job, Weiterbildung für IT-Fachkräfte.

Fachinformatiker.de App

Download on the App Store
Get it on Google Play

Kontakt

Hier werben?
Oder sende eine E-Mail an

Social media u. feeds

Jobboard für Fachinformatiker und IT-Fachkräfte

×
×
  • Neu erstellen...