Methoden Methode istDurchZahlTeilbar schreiben

[chrisööö]

Hallo,
ich habe hier folgende Aufgabe:

Es sollte eine Methode istDurchZiffernTeilbar realisiert werden ohne
if-Anweisung und Schleifen. Die Methode sollte true übergeben, wenn
die Zahl, die an die Methode übergeben wurde 0 ist oder sie durch alle
ihre Ziffern teilbar ist. Also 312 oder 3102 würde true zurückgeben, da
312 durch 3, 1 und 2 teilbar ist, ebenso 3102. Bei 525 würde false
zurückgegeben, da 525 nicht durch 2 teilbar ist. Es durften zusätzliche
Methoden impementiert werden.
Public stativ boolean istDurchZiffenTeilbar(int zahl){
…}

Irgendwie komme ich auf keine Lösung.
Meine Anfänge scheitern alle früher oder später.

Was ich bis jetzt hatte ist:

public static boolean istDurchZahlTeilbar(int zahl) {
return (zahl == 0)? true : ((zahl/ ermittelTeiler(zahl))%2 == 1)? false : istDurchZahlTeilbar(Zahl/10);

public static int ermittelTeiler(int zahl) {
return zahl%10;

Irgendwie bis jetzt alles Murks -.-

 

[Michael...]

Ohne Schleifen? Dann bleibt nur Rekursion.

Ich würde ersteinmal damit anfangen die Zahl rekursiv in ihre einzelnen Ziffern zu zerlegen und im zweiten Schritt die Teilbarkeit prüfen.

Edit: Wobei man dann aber nicht ohne Überprüfung einer Bedingung auskommt?? Die Aufgabenstellung lautet echt ohne Schleifen und Bedingungsabfragen??

 

[bERt0r]

Lustige Aufgabenstellung, sag deinem Prof dass

(zahl == 0)? true : ((zahl/ ermittelTeiler(zahl))%2 == 1)? false : istDurchZahlTeilbar(Zahl/10)

das gleiche wie eine If Anweisung ist, nur auf unleselich.

Ausserdem 155/10 = 15,5; 155%10 = 5

 

[Michael...]

Wobei Du in Deinem Bsp einen ternären Operator verwendest. Der zählt nicht als If Abfrage und ist erlaubt?

 

[Monaria]

Spontan und nur minimal getestet :

public class DurchNummernTeilbar{
	
	public static void main(String[] args){
		System.out.println(isDurchZiffernTeilbar(250));
	}
	
	private static boolean isDurchZiffernTeilbar(int n){
		return((n == 0 ) || 
                (
                doesNotContainZero(n)
		&& ((n % 2 == 0) || !contains(n, 2))
		&& ((n % 3 == 0) || !contains(n, 3))
		&& ((n % 4 == 0) || !contains(n, 4))
		&& ((n % 5 == 0) || !contains(n, 5))
		&& ((n % 6 == 0) || !contains(n, 6))
		&& ((n % 7 == 0) || !contains(n, 7))
		&& ((n % 8 == 0) || !contains(n, 8))
		&& ((n % 9 == 0) || !contains(n, 9))
                ));
	}
	
	private static boolean contains(int n, int i){
		return String.valueOf(n).contains(String.valueOf(i));
	}
	private static boolean doesNotContainZero(int i){
		return !(String.valueOf(i).contains("0") && String.valueOf(i).length() > 1);
	}
}

 

[Michael...]

Ausserdem 155/10 = 15,5;

Bei einer Ganzzahldivision ist das Ergebnis 15

 

[chrisööö]

Ja die soll nur mit Rekursion gelöst werden. Das ist ja die Schwierigkeit bei der Aufgabe. Mit Schleifen hätte ich die Lösung ja -.-

Mein Problem ist die Uhrsprüngliche Zahl durch alle ihre einzelnen Zahlen zu Teilen (mittels Rekursion).
Ich finde da einfach keine Lösung.

 

[Gonzo17]

Soll 3102 tatsächlich auch gelten? Da ist nämlich die 0 enthalten und durch 0 teilen ist ja eigentlich nicht so dolle.

Ansonsten ist das, was du da machst auch nichts anderes als ein if, glaube nicht, dass das so gedacht war. Stattdessen würde ich zB eine Methode schreiben istNull(char), die einene einzelne Ziffer auf 0 prüft =>

return c=='0';

 

[chrisööö]

Ich habe eine ähnliche Aufgabe schonmal gelöst. Allerdings wurden dort die Intervalle der Teile mit übergeben. Bei der aktuellen muss ich diese ja selber aus der Zahl ermitteln. Das ist mein Problem. Hier mal die andere bereits gelöste Aufgabe:

public static boolean hatTeiler2(int zahl, int intervallVon, int intervallBis) {
        return (zahl%intervallVon==0)?
            true : (intervallVon == intervallBis)?
                false : hatTeiler2(zahl, intervallVon+1, intervallBis);
    }

 

[bone2]

wie wäre es mit durch 10 teilen? wenn das ergebnis >0 ist, rufst du dich selber nochmal auf, wenn nicht bearbeitest du den rest
so würdest du an jede einzelne ziffer rankommen

 

[RySa]

Also irgendwie ist da was falsch verstanden/interpretiert worden. Du sagtest es solllen keine If-Anweisungen genutzt werden. Und was ist das denn bitte schön ?:

        return (zahl%intervallVon==0)?
            true : (intervallVon == intervallBis)?
                false : hatTeiler2(zahl, intervallVon+1, intervallBis);

für mich ist das nur eine andere (schlecht zu lesende) Schreibweise von:

if (zahl % intervallVon == 0){
 return intervallVon == intervallBis;
}
else {
return hatTeiler2(zahl,intervallVon+1, intervallBis);
}

Oder etwa nicht ?

 

[chrisööö]

So soll es aber sein. Das ist Rekursion ohne If-Anweisungen.

 

[RySa]

Das ist doch genau die selbe if-Anweisung. Rekursion hat da mit der Schreibweise nichts zu tun, mein Beispiel ist genauso rekursiv wie deins. Und dein Beispiel beinhaltet die selbe If-Anweisung wie meins, nur halt anders geschrieben (in anderem Format ? ).

Deswegen verstehe ich nicht ganz, wie das ohne If's umgesetzt werden sollte...

 

[chrisööö]

Steht doch dort. Ohne If bedeutet nur mit Operatorsymbolen ?:

Ganz klar oder?

Wenn du das ganze mit If lösen kannst ist mir das auch recht. Dann forme ich das selber um. Allerdings würde mir auch eine If Schreibweise jetzt keine Lösung bieten -.-

 

[RySa]

So spontan, ohne große Tests, vielleicht so etwas:

public class Rekursion {

	public static boolean isZahlTeilbar(int zahl, int marker){
		String[] s = (""+zahl).split("");
		try {
			if (zahl % Integer.valueOf(s[marker]).intValue() == 0){
				return isZahlTeilbar(zahl,marker+1);
			}
			else {
				return false;
			}
		}
		catch(ArrayIndexOutOfBoundsException ex){
			return true;
		}
                catch(ArithmeticException ex){
			return false;
		}

		
	}
	
	
	public static void main(String agrs[]){
		System.out.println(isZahlTeilbar(312,1));
	}
}

Als marker immer eine 1 am Anfang übergeben (hatte keine andere Idee ^^) - hatte nie zuvor Rekursion angewendet

Soll 3102 tatsächlich auch gelten? Da ist nämlich die 0 enthalten und durch 0 teilen ist ja eigentlich nicht so dolle.

Hier schließe ich mich dem Gonzo17 an, daher das return false bei ArithmeticException

 

[chrisööö]

Problem ist, dass der Methode ausser der "Zahl" nichts übergeben werden darf. Also kein Marker.
Ebenfalls keine anderen Methoden wie valueof etc. Andere Methoden selber schreiben ist erlaubt, allerdings wiederum ohne Hilfe vorgefertigter anderer Methoden.
Es muss dafür eine Elegante Lösung geben, die mir aber einfach nicht einfallen will.

 

[RySa]

Vielleicht soll auch die Benutzung der Variablen verboten werden ? Also wenn ich sage, mach mir ein Spiegelei, du darfst dafür aber keine Eier nutzen, wird das nichts....split() und valueOf() sind standard-Methoden von String, und da sehe ich es nicht ein, dass sie nicht benutzt werden dürfen Soll ich sie jetzt selber mal als Code bei mir einfügen damit ich die benutzen kann ? Wo bleibt die Logik ? Das ist das gleiche als ob dir Verboten wäre Rechenoperationen zu benutzen "weil sie vorgefertigt sind"...Jedenfalls ist meiner Meinung nach diese Lösung in Ordnung:

public class Rekursion {

	public static boolean isZahlTeilbar(int zahl) {
		return checkTeiler(zahl, 1);
	}

	public static boolean checkTeiler(int zahl, int marker) {
		String[] s = ("" + zahl).split("");
		try {
			if (zahl % Integer.valueOf(s[marker]).intValue() == 0) {
				return checkTeiler(zahl, marker + 1);
			} else {
				return false;
			}
		} catch (ArrayIndexOutOfBoundsException ex) {
			return true;
		} catch (ArithmeticException ex) {
			return false;
		}
	}

	public static void main(String agrs[]) {
		System.out.println(isZahlTeilbar(312));
	}
}

Du musst dann nur die If's, umformen (ich benutze diese 2. Variante nie, deswegen überlasse ich es dir ^^)

 

[Mofi]

Vielleicht soll auch die Benutzung der Variablen verboten werden ? Also wenn ich sage, mach mir ein Spiegelei, du darf dafür aber keine Eier nutzen, wird das nichts....split() und valueOf() sind standard-Methoden von String, und da sehe ich es nicht ein, dass sie nicht benutzt werden dürfen Soll ich sie jetzt selber mal als Code bei mir einfügen damit ich die benutzen kann ? Wo bleibt die Logik ? Das ist das gleiche als ob dir Verboten wäre Rechenoperationen zu benutzen "weil sie vorgefertigt sind"...Jedenfalls ist meiner Meinung nach diese Lösung in Ordnung:

Ich find die Aufgabenstellung ansich schon total daneben...
Ich mein, dass man keine Schleifen verwenden soll...OK
Aber man soll keine if-Verzweigung benutzen, aber darf den ?: Operator benutzen (hab den Namen vergessen...Irgendwas mit ter...tertiärer?) Ich mein das ergibt nichtmal Ansatzweise Sinn.
Das man scheinbar dann auch Standardmethoden nicht benutzen darf ergibt in der Aufgabenlogik dann eventuell schon mehr Sinn (Konsequenz und so...)

Mir raucht grad der Kopf, daher hab ich mir deine Lösung nicht weiter angeschaut und hab meine eigene auch wieder Verworfen...Krieg heut kaum was auf die Reihe....


(Und nein es ist in meinen Augen NICHT logisch, wenn da steht "benutze keine if-Verzweigung" das man dann den ?: benutzen darf...Wäre mir nie in den Sinn gekommen)

 

[nillehammer]

Ich hab mir mal ein paar Gedanken gemacht. Dabei ist folgendes Rausgekommen:
[Java]
public final class Experiment {

public static void main(final String[] args) {

final int zahl = 1124;

/*
* Mit Math.abs sorgen wir dafür, dass der Algorithmus eine positive
* Zahl bekommt, weil Modulo mit negativen Zahlen nicht funktioniert.
*/

final int positiveZahl = Math.abs(zahl);
/*
* Durch die Verwendung des absteigend sortierten Sets (new
* TreeSet<Integer>( Collections.reverseOrder()), werden zwei Optimierungen
* vorgenommen: 1. Doppelt vorkommende Ziffern werden eliminiert. Damit
* werden Doppelprüfungen vermieden 2. Die Wahrscheinlichkeit, dass eine
* Zahl durch eine große Ziffer NICHT teilbar ist, ist größer als bei
* kleineren. Dadurch wird bei der rekursiven Prüfung der Teilbarkeit ggf.
* die Abbruchbedingung schneller erreicht. Durch die absteigende Sortierung
* werden die großen Ziffern zuerst geprüft.
*/
final SortedSet<Integer> ziffern = doZerlegung(new TreeSet<Integer>(
Collections.reverseOrder()), positiveZahl);

/*
* Durch 0 kann nicht dividiert werden, deswegen aus der Menge zu prüfender
* Ziffern entfernen.
*/
ziffern.remove(0);

/*
* Jede Zahl ist durch 1 teilbar. Eine Prüfung macht keinen Sinn, also
* entfernen.
*/
ziffern.remove(1);

System.out.println(istDurchAlleZiffernTeilbar(ziffern.iterator(),
positiveZahl));

}

/**
* Zerlegt eine Zahl in ihre Ziffern und gibt das Ergebnis in einem
* {@link SortedSet} zurück.
*
* @param input
* das {@link SortedSet}, in dem das Ergebnis der Zerlegung
* gespeichert werden soll, darf nicht null sein
* @param positiveZahl
* die Zahl, die zerlegt werden soll, muss positiv sein
* @return ein {@link SortedSet}, dass die Ziffern enthält, aus der die Zahl
* besteht
*/
public static final SortedSet<Integer> doZerlegung(
final SortedSet<Integer> input, int positiveZahl) {

input.add(positiveZahl % 10);

positiveZahl /= 10;

return positiveZahl > 0 ? doZerlegung(input, positiveZahl) : input;
}

public static boolean istDurchAlleZiffernTeilbar(
final Iterator<Integer> ziffernIterator, final int zahl) {

/*
* Wenn ziffernIterator.hasNext() == true, müssen wir zunächst die
* Teilbarkeit durch die aktuelle Ziffer prüfen.
*
* ((zahl % ziffernIterator.next() == 0))
*
* Ergibt dies false, geben wir das direkt zurück (Abbruchbedingung). Wir
* nutzen hier die Funktionalität des Shortcuts "&&". Dieses wertet den
* zweiten Teil der Bedingung garnicht mehr aus, wenn der erste schon false
* ist.
*
* Ergibt diese allerdings true, müssen wir mit der nächsten Ziffer weiter
* machen.
*
* Wenn ziffernIterator.hasNext() == false, haben wir alle Ziffern
* durchgeprüft. Also können wir true zurück geben
*/
return ziffernIterator.hasNext() ? (zahl % ziffernIterator.next() == 0)
&& istDurchAlleZiffernTeilbar(ziffernIterator, zahl) : true;
}

}
[/code]
Vorteile:
-Auf die Zerlegung der Zahl in Strings zur Ziffernermittlung wird verzichtet.
-Doppelt vorkommende Ziffern werden nur einmal geprüft
-Die Prüfung auf Teilbarkeit durch 1 (immer wahr) und 0 (nicht möglich) wird vermieden.
-Große Ziffern werden zuerst geprüft, weil hier die Wahrscheinlichkeit größer ist, dass die Teilbarkeitsprüfung negativ ausfällt und somit die Abbruchbedingung der Rekursion erreicht wird.

Gruß nillehammer

 

[chrisööö]

Ich find die Aufgabenstellung ansich schon total daneben...
Ich mein, dass man keine Schleifen verwenden soll...OK
Aber man soll keine if-Verzweigung benutzen, aber darf den ?: Operator benutzen (hab den Namen vergessen...Irgendwas mit ter...tertiärer?) Ich mein das ergibt nichtmal Ansatzweise Sinn.
Das man scheinbar dann auch Standardmethoden nicht benutzen darf ergibt in der Aufgabenlogik dann eventuell schon mehr Sinn (Konsequenz und so...)

Mir raucht grad der Kopf, daher hab ich mir deine Lösung nicht weiter angeschaut und hab meine eigene auch wieder Verworfen...Krieg heut kaum was auf die Reihe....


(Und nein es ist in meinen Augen NICHT logisch, wenn da steht "benutze keine if-Verzweigung" das man dann den ?: benutzen darf...Wäre mir nie in den Sinn gekommen)

An der Aufgabenstellung kann ich nunmal auch nichts ändern. Allerdings geht es mir heute genauso das ich das einfach nicht hin bekomme und jeden Ansatz wieder verwerfen muss -.-

 

[Sonecc]

Man kann über die Aufgabenstellung soviel mosern wie man will, aber sie ist nunmal gegeben.
Ich vermute mal ganz stark, dass sein Professor damit das abstrakte Denken und erarbeiten einer Lösung trainieren will.
In der Uni ist nicht jede Aufgabe wirklich sinnvoll und völlig Diskussionsfrei.
Warum Rysa sich da aber dermaßen drüber aufregen muss ist mir schleierhaft.

Was aber die Problematik mit der Verwendung von If betrifft:
Der Ternäre Operator ist per Definition ein Inline - If und damit meiner Meinung nach eigentlich ebenfalls verboten.
Nicht verboten sollte aber etwas sein wie:

return a > 0

Edit: Muss aber zugeben, ohne If ist es recht schwer eine Abbruchbedingung für die Rekursionen zu definieren.

 

[RySa]

Also ich meine, dass meine Lösung funktioniert. Wenn du aber schon Methoden wie split() und valueOf nicht benutzen darfst, dann wünsche ich dir viel Glück bei der Aufgabe. Überlege es dir vielleicht, ob 10 Jahre im Knast, für den Mord an deinem Prof. dir nicht kürzer kommen, als die Zeit die du für diese Aufgabe benötigen wirst Aber jetzt ernst. Wieso zum Henker sollte man solche Methoden nicht nutzen können. Dann kannst du direkt "Kodierer" werden, und mit 0 und 1 arbeiten, wenn du vorgefertigtes Zeug nicht benutzen darfst. Das Rad immer wieder Neuerfinden ist einfach Sinnlos. Auch wenn du diese Aufgabe "beweltigst", wird es dir nicht weiterhelfen, da du im Normalfall, die Methoden nutzen würdest, anstatt sie neu zu schreiben.

Ein typisches Beispiel, wie die Unis Unnützes Wissen "beibringen".

 

[nillehammer]

Nochwas zu meinem Lösungsvorschlat (4 Posts weiter unten). Wenn der ternäre Operator (? : ) nicht erlaubt ist, sag Bescheid. Dann muss man mit geschickten Shortcuts durch && arbeiten. Wenn SortedSets nicht erlaubt sind, geht auch. Dann ist der Algorithmus allerdings nicht mehr optimiert.

 

[RySa]

@ nillehammer

Ich würde eher vermuten, dass das alles nicht erlaubt ist:

Math.abs(zahl), Collections.reverseOrder(), ziffern.remove(0), ziffern.iterator(), input.add(positiveZahl % 10), ziffernIterator.next()

Weil es schon vorgefertigte Methoden sind.



Also hier nochmal mit dem Ternären Operator:

public class Rekursion {
 
    public static boolean isZahlTeilbar(int zahl) {
        return checkTeiler(zahl, 1);
    }
 
    public static boolean checkTeiler(int zahl, int marker) {
        String[] s = ("" + zahl).split("");
        try {
            boolean b = (zahl % Integer.valueOf(s[marker]).intValue() == 0) ? checkTeiler(zahl, marker + 1) : false;
            return b;
        } catch (ArrayIndexOutOfBoundsException ex) {
            return true;
        } catch (ArithmeticException ex) {
            return false;
        }
    }
    
    
 
    public static void main(String agrs[]) {
        System.out.println(isZahlTeilbar(31062));
    }
}

Bis auf das split() und valueOf() ist glaube ich alles ok. Anders werde ich es nicht lösen können. Viel Glück bei weiteren Versuchen

 

[bERt0r]

Etwas in der Richtung?

static boolean istTeilbar(int zahl)
	{
		return teile(zahl,zahl);	
	}
	
	static boolean teile(int zahl,int zahl2)
	{
		System.out.println(zahl+" "+zahl2);
		int ziffer=zahl2%10;
		ziffer=(ziffer==0)?1:ziffer;
		boolean teilt=(zahl%ziffer==0);
		boolean done=(zahl2==0);
		return (done)?true:(teilt)?teile(zahl,zahl2/10):false;
	}
	
	public static void main(String args[])
	{
		System.out.println(istTeilbar(3103));
	}

 

[xehpuk]

Ich werfe auch mal eine Lösung in den Raum, die das Ganze in ein paar Teilprobleme aufteilt.

public class ZahlZiffernTest {
	public final static int BASIS = 10;

	/**
	 * Überprüft, ob die Zahl durch all ihre Ziffern teilbar ist.
	 */
	public static boolean istDurchZiffernTeilbar(int zahl) {
		return istDurchZiffernTeilbarAb(zahl, 0);
	}

	/**
	 * Überprüft ab dem angegebenen Index aufwärts (nach links), ob die Zahl durch alle Ziffern teilbar ist.
	 */
	private static boolean istDurchZiffernTeilbarAb(int zahl, int index) {
		return index >= anzahlZiffern(zahl) || istDurchZifferTeilbar(zahl, index) && istDurchZifferTeilbar(zahl, index + 1);
	}

	/**
	 * Überprüft, ob die Zahl durch die Ziffer beim angegebenen Index (von rechts) teilbar ist.
	 */
	private static boolean istDurchZifferTeilbar(int zahl, int index) {
		return istTeilbarDurch(zahl, gibZiffer(zahl, index));
	}

	/**
	 * Überprüft, ob Divisor ein ganzzahliger Teiler von Dividend ist. Gibt auch true zurück, wenn Divisor == 0.
	 */
	private static boolean istTeilbarDurch(int dividend, int divisor) {
		return divisor == 0 || dividend % divisor == 0;
	}

	/**
	 * Gibt die Ziffer der Zahl beim angegebenen Index (von rechts) wieder. 0, wenn Index >= Anzahl der Ziffern.
	 */
	private static int gibZiffer(int zahl, int index) {
		return (zahl / potenz(BASIS, index)) % BASIS;
	}

	/**
	 * Gibt basis^exponent zurück.
	 */
	private static int potenz(int basis, int exponent) {
		return exponent <= 0 ? 1 : basis * potenz(basis, exponent - 1);
	}

	/**
	 * Gibt die Anzahl der Ziffern dieser Zahl zurück.
	 */
	public static int anzahlZiffern(int zahl) {
		return zahl < BASIS ? 1 : 1 + anzahlZiffern(zahl / BASIS);
	}

	public static void main(String[] args) {
		int[] zahlen = { 3102, 312, 525 };
		for (int n : zahlen)
			System.out.println(String.valueOf(n) + ": " + istDurchZiffernTeilbar(n));
	}
}

 

[RySa]

@xehpuk

Ganz schön aufwendig ^^ Wenns funktioniert, dann könnte es die vom TO gesuchte Lösung sogar sein Bis auf das letzte:

String.valueOf(n)

Da würd glaub' ich sein Prof. meckern (nicht deine Methode)^^ vielleicht lieber doch

""+n

 

[parabool]

public class Test {
	
	public static void main(String[] args) {
			
		System.out.println("ist Teilbar="+isT(312,0));		
	}
	private static boolean isT(int z,int i)
	{					
		int t = Character.getNumericValue(String.valueOf(z).charAt(i));
		i++;	
		
		if(t==0)return false;			
		if(z%t!=0)return false;	
				
		if(i>String.valueOf(z).length()-1)return true;
		else return isT(z,i);			
	}
}

 

[bone2]

Also irgendwie ist da was falsch verstanden/interpretiert worden. Du sagtest es solllen keine If-Anweisungen genutzt werden. Und was ist das denn bitte schön ?:

        return (zahl%intervallVon==0)?
            true : (intervallVon == intervallBis)?
                false : hatTeiler2(zahl, intervallVon+1, intervallBis);

für mich ist das nur eine andere (schlecht zu lesende) Schreibweise von:

if (zahl % intervallVon == 0){
 return intervallVon == intervallBis;
}
else {
return hatTeiler2(zahl,intervallVon+1, intervallBis);
}

Oder etwa nicht ?

eher:

if (zahl%intervallVon==0) {
    return true;
}
else {
    if (intervallVon == intervallBis) {
        return false;
    }
    else {
        return hatTeiler2(zahl, intervallVon+1, intervallBis);
    }
}

 

[RySa]

Ja das ist mir dann im Laufe der Versuche auch bewusst geworden, dass es nicht so ganz gestimmt hat. Da wollte ich halt nur darauf hinaus, dass es genauso eine If-Anweisung ist, die schreibweise nur anders. Danke aber für die Korrektur

 

[xehpuk]

Das

String.valueOf(n)

kann man ja auch weglassen, da danach konkateniert wird. Aber zu Testzwecken darf man ja wohl auch auf anderes zugreifen.
Wobei ich gerade sehe, dass bei mir noch nicht die letzte Ziffer richtig betrachtet wird …
Bei Zahlproblemen würde ich aber auch nicht den Weg über Strings gehen. Da macht man es sich zu einfach und um Einiges ineffizienter wirds wohl auch sein.

 

[bERt0r]

Ich glaube dass Stringfunktionen hier gar nicht erlaubt sind...

 

[bERt0r]

Sry für den doppelpost, aber bevors untergeht:
Mein code funktioniert schon, aber die zahl 3103 die ich eingegeben habe ist eben nicht teilbar

 

[xehpuk]

Okay, Fehler gefunden. Durch einen kleinen Schreibfehler hatte ich keine richtige Rekursion drin. Hier korrigiert ("istDurchZifferTeilbar" --> "istDurchZiffernTeilbarAb"):

[JAVA=14] private static boolean istDurchZiffernTeilbarAb(int zahl, int index) {
return index >= anzahlZiffern(zahl) || istDurchZifferTeilbar(zahl, index) && istDurchZiffernTeilbarAb(zahl, index + 1);
}[/code]
Diese Lösung ist dann mindestens 10-mal schneller als über Strings.

 

[xehpuk]

Und die von bERt0r etwa nochmal dreimal schneller als meine. Ich wollte aber ohne Lokalvariablen auskommen.

Ups, wollte ich eigentlich an den vorigen Beitrag raneditieren. Bitte mergen.

 

[parabool]

Ok, ohne If :

EDIT: Berücksichtigt wenn Eingabe = 0 -> true.

public class Test {
	
	public static void main(String[] args) {
			
		System.out.println("ist Teilbar="+isT(0,0,0));		
	}
	private static boolean isT(int z,int i,int ret)
	{					
		int t = 0;
		try
		{
		 t = Character.getNumericValue(String.valueOf(z).charAt(i));	
		 ret+=z%t;
		}
		catch(java.lang.ArithmeticException r)
		{
			return false || z==0;
		}	
		catch(StringIndexOutOfBoundsException r)
		{			
			
			return (ret==0);
		}	
		return isT(z,++i,ret);			
	}
}

 

[Svente]

Wie wäre es die Kurzschlussoperatoren zur Bedingungsüberprüfung zu "missbrauchen"?

Meine Lösung:

[Java]

public class Test {


public static boolean isDurchZahlTeilbar( int zahl){
return testeZiffern(zahl, zahl);
}


private static boolean testeZiffern(int restZiffern, int zahl){
int ziffer =restZiffern%10;

return restZiffern<10

||

((ziffer==0||(zahl%ziffer==0)) && testeZiffern(restZiffern/10, zahl));
}
}
[/code]

 

[bERt0r]

Svente, bei deinem Code wird die erste Ziffer nicht mehr überprüft, also im fall von 5102, sagt er true.

private static boolean testeZiffern(int restZiffern, int zahl){
        int ziffer =restZiffern%10;
        System.out.println(restZiffern);
        return [B] restZiffern==0[/B] || ((ziffer==0||(zahl%ziffer==0)) && testeZiffern(restZiffern/10, zahl));
    }

So funktionierts, und das is ja dann quasi das gleiche wie meine Lösung

 

[Svente]

Stimmt, ansonsten bricht er einfach eine Rekusion zu früh ab.

Der Unterschied zu deiner Lösung sollte in der Vermeidung des ternärer Operator liegen. Die Idee war diesen durch den Kurzschluss der Vergleichoperatoren || bzw && und zu ersetzen .