Dumme Frage, aber...

[Equated]

Ich hab mir eine Aufgabe auf http://www.programmieraufgaben.ch angeschaut und versucht, zu lösen. Sie sieht wie folgt aus:

Schreiben Sie ein Programm, welches überprüft ob eine natürliche Zahl defiziente ist oder nicht.

Eine natürliche Zahl heißt defizient, wenn ihre echte Teilersumme (die Summe aller Teiler ohne die Zahl selbst) kleiner ist als die Zahl selbst. Ist die Teilersumme dagegen gleich der Zahl, spricht man von einer vollkommenen Zahl, ist sie groeßer, so spricht man von einer abundanten Zahl.

z.B : Eingabe: 80

Ausgabe: 80 ist keine defiziente Zahl [ 1 + 2 + 4 + 5 + 8 + 10 + 16 + 20 + 40 = 106 ].


An sich ist die Frage gar nicht schwierig, aber beim Programmieren kommt bei mir immer das Falsche raus. 80 soll keine defiziente Zahl sein, aber ich krieg immer das Gegenteil!?

Mein Code:

public class Runner {
   public static void main(String[] args) {
     Test t=new Test();
     System.out.println(t.Ueberpruefer(80));
   }
}

---------------------------------------------------------------------------------------------------
public class Test { 
   public String Ueberpruefer(int zahl)
   { for(int i=1; i<=zahl; i++)   
   { 
     int sum=0;
if(zahl%i==0)
      sum+=i;
    sum=sum-zahl;  
     
      if(sum>zahl)
      { return "Die Zahl ist nicht defizient!"; }
 
   }return "Die Zahl ist defizient";}
}

Bitte helft einem dummen Menschen bei der Fehlersuche. Ich steh auf dem Schlauch...

 

[Dukel]

Kannst du den Code in Code Tags stellen? Was kommt denn bei dir bei Sum heraus?

 

[Tarrew]

Also das liegt an 2 Sachen.

1. Wenn die Zahl durch i teilbar ist, dann rechnest du sum+=i, das ist richtig. Aber wofür ist das sum=sum-zahl ? Das solltest du löschen.

2. Du deklarierst die Variable sum in jedem Schleifendurchlauf neu. Deswegen wird nach jedem Schleifendurchlauf bei 0 angefangen. Du musst die Variable außerhalb der Schleife deklarieren.

 

[Jardcore]

Durch die total verwurschtelte Formatierung kann man nicht erkennen ob und wo der Fehler ist, denn die Klammern sind schon totaler Mist

void main() {
  int zahl = 80;

  int sum = 0;
  for(int i = 0; i < zahl; i++) {
    if(zahl % i == 0) {
      sum += i;
    }
  }

  if(sum < zahl) {
    print('defizient');
  } else {
    print('nicht defizient');
  }
}

Hier mal ein Code aus Dart, so funktioniert es, und ich glaube dein Ansatz ist der gleiche.

 

[CSHW89]

Zwei Dinge zum Code von Jardcore. Erstens sollte man nicht bei 0 anfangen. Bin mir gerade nicht ganz sicher, aber modulo von 0 sollte ein Fehler schmeißen. Außerdem braucht man nicht bis 'zahl' prüfen, da man diesem Fall eh ausschließt. Also höchstens bis 'i < zahl' iterieren (wurde gerade schon korrigiert), oder noch besser 'i <= zahl/2', da 'zahl/2' der größte mögliche Teiler ist.

Man könnte es jetzt noch weiter optimieren, wenn man von 2 bis wurzel(zahl) iteriert und immer 'i' und 'zahl/i' hinzuaddiert, aber da muss man sehr auf die Grenzen aufpassen. Ich glaube, das würde hier jetzt zu weit führen.

lg Kevin

 

[Xyz1]

Mach es doch so:

    private static ArrayList<Integer> getTeiler(int value) {
        ArrayList<Integer> ali = new ArrayList<Integer>();
        for (int i = 1; i <= value / 2; i++) { // diese Schleife könnte schneller gemacht werden
            if (value % i == 0) {
                ali.add(i);
            }
        }
        return ali;
    }

    private static int getKat(int value, int sum) {
        if (sum < value) {
            return 1; // defizient
        } else if (value == sum) {
            return 2; // vollkommen
        } else {
            return 3; // abundant... es wird kleiner
        }
    }

switch (getKat(i, getSum(getTeiler(i)))) { ......

0              [] : vollkommen
1              [] : defizient
2             [1] : defizient
3             [1] : defizient
4          [1, 2] : defizient
5             [1] : defizient
6       [1, 2, 3] : vollkommen
7             [1] : defizient
8       [1, 2, 4] : defizient
9          [1, 3] : defizient
10       [1, 2, 5] : defizient
11             [1] : defizient
12 [1, 2, 3, 4, 6] : abundant

eine Summenfunktion müsstest du selber schreiben, das finde ich ganz gut

 

[Jardcore]

aber modulo von 0 sollte ein Fehler schmeißen

Java scheint da wohl anfälliger zu sein Hatte es eben nur fix mit https://dartpad.dartlang.org/ geprüft und dort ist es egal ob Null oder nicht Null

Durch zahl / 2 ist der ganze Prozess natürlich doppelt so schnell

 

[Equated]

Danke für die Antworten. Meine Lösung sieht jetzt so aus:

public class Runner {
   public static void main(String[] args) {
  
   Test t=new Test();
   System.out.println(t.Ueberpruefer(80));
  
   }
}

-------------------------------------------------------------------
public class Test {
   public String Ueberpruefer(int zahl)
   {
     int sum=0;
  
     for(int i=1; i<zahl; i++)
    
     { if(zahl%i==0)
  
       {
        sum+=i;      
        if(sum<zahl)
        {
            return "Das ist eine defiziente Zahl";
        }      
       } 
     }
  return "Das ist keine defiziente Zahl";
   }
}

Ich hoffe das sieht von den Klammern her in Ordnung aus. :/

 

[Jardcore]

Benutzte bitte das nächste Mal bitte die [ code ][ /code ] Tags!
Guck Mal wie schön das aussehen kann

public class Runner {

    public static void main(String[] args) {

        Test t = new Test();
        System.out.println(t.Ueberpruefer(80));
    }
}

public class Test {
    public String Ueberpruefer(int zahl) {
        int sum = 0;

        for(int i = 1 ; i < zahl; i++) {
            if(zahl % i == 0) {
                sum += i;
     
                if(sum < zahl) {
                    return "Das ist eine defiziente Zahl";
                }
            }
        }

        return "Das ist keine defiziente Zahl";
    }
}

Ich würde aber trotzdem empfehlen die Schleife nur bis zahl / 2 zu zählen und deine Abfrage if(sum < zahl) { } hinter die Schleife zu legen. Unt zusätzlich die Methode Ueberpruefe() klein zu schreiben und den Rückgabewert in boolean zu ändern.

Sonst vermischt du Logik mit GUI Kram.
also

if(t.ueberpruefe(80) {
    System.out.println("Das ist eine defiziente Zahl");
} else {
    System.out.println("Das ist keine defiziente Zahl");
}

 

[Flown]

Bitte deinen Code das nächste Mal in Code-Tags geben: [code=java]JAVA CODE HERE[/code]

 

[kneitzel]

Das if (sum < zahl) ist ja in der Schleife und das ist doch Unsinnig. So brichst Du die Schleife ab, sobald das erste mal sum erhöht wurde und sum<zahl ist.

Und wieso testest Du deinen Code nicht selbst? Du kannst die Funktion in einer main Funktion doch mit verschiedenen Argumenten aufrufen und das Ergebnis dann überprüfen!

 

[Equated]

So jetzt stimmt alles! Ich komm mir so blöd vor :/ aber Hauptsache ich habs endlich verstanden!
Danke für eure Unterstützung

Das ist raus gekommen: (auch getestet)

public class Runner {
   public static void main(String[] args) {
     // TODO Auto-generated method stub 
   
   Test t=new Test();
   t.Ueberpruefer(80);
   }
}

public class Test {
   public boolean Ueberpruefer(int zahl)
   {
     int sum=0;
   
     for(int i=1; i<zahl; i++)
     
     { if(zahl%i==0)
       {
        sum+=i;
       }
     }
         if(sum<zahl)
           {
            System.out.println("Das ist eine defiziente Zahl");
             return true;
           }
     else
       System.out.println("Das ist keine defiziente Zahl");
       return false;
   }
}

 

[Jardcore]

besser 'i <= zahl/2', da 'zahl/2' der größte mögliche Teiler ist.

Das solltest du vielleicht noch einbauen. Teste mal mit großen Zahlen, da wird die Laufzeit ziemlich mies. Und mit dem kleinen Trick kannst du sie schon mal halbieren

 

[Equated]

werd ich machen. dankeschön

 

[Joose]

Kleine Anmerkung zu deinem Code: Achte auf eine korrekte Einrückung (eine IDE hilft dir dabei), dadurch wird der Code lesbarer und gewisse Fehler lassen sich anhand der Einrückung schon erkennen.

Beispiel:

     else
       System.out.println("Das ist keine defiziente Zahl");
       return false;
   }
}

Laut Einrückung schaut es so aus als sollte "return false" teil des else-Block sein. Da aber dein else keine Klammern hat wird nur die direkt darauffolgende Anweisung Teil des else-Block.
Außerdem rate ich auch wenn nur eine Anweisung in einem if- oder else-Block steht immer Klammern zu verwenden (besser mal zu viel machen, als vergessen und der Code macht etwas unerwartetes weil Klammern vergessen wurden )

public class Test {
   public boolean Ueberpruefer(int zahl) {
     int sum = 0;
     for(int i=1; i<zahl; i++) {
       if(zahl % i == 0) {
         sum += i;
       }
     }
     if(sum < zahl) {
       System.out.println("Das ist eine defiziente Zahl");
       return true;
     } else {
       System.out.println("Das ist keine defiziente Zahl");
     }
     return false;
   }
}

 

[Xyz1]

Ich will mich nicht zu weit aus dem Fenster lehnen, den dafür haben wir ja echte Mathem., aber wie wäre es, erst eine Primfaktorzerlegung durchzuführen und dann alle Teiler zu bestimmen.
Dann ist die Schleife schon schneller.
Dann auch noch mal hier schauen:
http://www.homeconstructor.de/programm-in-java-alle-teiler-einer-zahl.html
alle teiler einer zahl ausgeben
20.04.2005
Perfekte Zahlen errechnen
24. Okt. 2010
Teiler einer Zahl ermitteln
9. Nov. 2009
Alle Teiler einer Zahl performant berechnen?
28. Mai 2007
Teiler einer ganzen Zahl
2. Nov. 2006