Markoff-Zahl

ocsme

Top Contributor
Guten Tag zusammen,

ich hab ein Problem und komme einfach auf keine Lösung :( Eigentlich ist die Aufgabe die ich hier versuche überhaupt nicht schwer doch Ich bekomme es nicht hin :(

Also ich versuche die Markoff-Zahlen zu programmieren. Das ganze versuche ich so das ich ein Array erstelle dort die Quersummen der Zahlen speichern möchte und dann drüber laufen will ob die Quersumme in dem Array schon vorhanden ist doch ich bekomme ja nicht mal die Zahlen vernünftig ins Array rein :(

Hier mal mein Versuch:

Code:
int n=10;
        int[] quersumme=new int[n*n];
        int counter=0;
        int tmp=0;
       
        for(int i=1;i<=n;i++) {
            for(int j=1;j<=n;j++) {
                for(int k=1;k<=n;k++) {
                if(i*i+j*j+k*k==3*i*j*k) {
                    tmp=i+j+k;
                    System.out.println(i+" "+j+" "+k+" "+tmp);

                }

                    }
                }
            }

Die Ausgabe ist:
1 1 1 3
1 1 2 4
1 2 1 4
1 2 5 8
1 5 2 8
2 1 1 4
2 1 5 8
2 5 1 8
5 1 2 8
5 2 1 8

Ich will jetzt alle Zahlen die ein doppelten tmp haben raus werfen. Doch immer wenn ich versuche eine neue Quersumme in mein Array zu speichern überschreibt er mir das ganze Array mit der gefunden quersumme. Ich hab keine Ahnung wie ich in so einer Schleifen-Kaskade vernünftig nochmal durch mein quersummen Array laufen kann.
Bin über jede Hilfreiche Antwort sehr dankbar :)

LG
 

ocsme

Top Contributor
Flown stimmt :D ich hab meinen ersten Versuch Kopiert grrr...
Hier mal der bis jetzt neue Versuch. Nun ist es gar nicht mehr ganz so schlimm :D Das Array wird mit Quersummen gefüllt doch noch immer so wie ich es gerne hätte. Denn es werden weiterhin Dupletten Kopiert :(

Java:
int n=100;
    int quersumme=0;
    int tmp=0;
    int[] qArray=new int[n*n];
    int counter=0;
   
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            for(int k=1;k<=n;k++) {
                if(i*i+k*k+j*j==3*i*k*j) {
                    tmp=quersumme;
                    quersumme=i+j+k;
                    if(tmp!=quersumme) {
                        qArray[counter]=quersumme;
                        System.out.println("("+i+","+k+","+j+")");
                        counter++;
                    }
                   
                }
            }
   
    for(int i=0;i<=counter;i++)
        System.out.println(qArray[i]);
 

ocsme

Top Contributor
ja weil ich es nicht anders hin bekomme :(
ich sitze hier schon seit stunden an sowas :( das ist sicherlich so schwer nicht doch ich bekomme es gerade überhaupt nicht hin. Ich denke ich werde es erstmal sein lassen sonst macht man sich nur Verrückt :D
 

Blender3D

Top Contributor
Also es geht darum die Markhoffzahlen zu ermitteln?
Eine Markoff-Zahl ist eine natürliche Zahl x , y oder z, die als Lösung der diophantischen Markoff-Gleichung
x^2 + y^2 + z^2 = 3*x*y*z vorkommt.
Die ersten Markoff-Zahlen sind 1, 2, 5, 13, 29, 34, 89, 169, 194, 233, 433, 610, 985, 1325, …

Man kann aus einer Lösung (x ,y ,z ) der Markoff-Gleichung mittels (x ,y ,z) → (x ,y ,3*x*y − z) weitere Lösungen erzeugen.

Ich würde ein Klasse für die Trippel bauen mit obigen Bedingungen.
z.B.
Java:
import java.util.Arrays;

public class MarkhoffTripple {
    private int[] values = new int[3];

    public MarkhoffTripple(int x, int y, int z) throws IllegalArgumentException {
        values[0] = x;
        values[1] = y;
        values[2] = z;
        setValues(values);
    }

    public MarkhoffTripple(int[] values) throws IllegalArgumentException {
        setValues(values);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        MarkhoffTripple other = (MarkhoffTripple) obj;
        if (!Arrays.equals(values, other.values))
            return false;
        return true;
    }

    public int getCrossSum() {
        return values[0] + values[1] + values[2];
    }

    public int[] getValues() {
        return Arrays.copyOf(values, values.length);
    }

    public MarkhoffTripple[] getFollower() {
        MarkhoffTripple[] neigbours = new MarkhoffTripple[2];
        if (getCrossSum() == 3) {
            neigbours = new MarkhoffTripple[1];
            neigbours[0] = new MarkhoffTripple(1, 1, 2);
            return neigbours;
        }
        if (getCrossSum() == 4) {
            neigbours = new MarkhoffTripple[1];
            neigbours[0] = new MarkhoffTripple(1, 2, 5);
            return neigbours;
        }
        int x = values[1];
        int y = values[2];
        int z = values[0];
        neigbours[1] = new MarkhoffTripple(x, y, 3 * x * y - z);
        x = values[0];
        y = values[2];
        z = values[1];
        neigbours[0] = new MarkhoffTripple(x, y, 3 * x * y - z);
        return neigbours;

    }

    public static boolean isMarkhoffTripple(int x, int y, int z) {
        return x * x + y * y + z * z == 3 * x * y * z;
    }

    private void setValues(int[] values) {
        if (values == null || values.length != 3 || !isMarkhoffTripple(values[0], values[1], values[2]))
            throw new IllegalArgumentException("No Markhofftripple!");
        this.values = Arrays.copyOf(values, values.length);
        Arrays.sort(this.values);
    }

    @Override
    public String toString() {
        return "[" + values[0] + "," + values[1] + "," + values[2] + "]";
    }
}
Java:
    public static void main(String[] args) {
        Vector<MarkhoffTripple> tripples = new Vector<MarkhoffTripple>();
        tripples.add(new MarkhoffTripple(1, 1, 1));
        getMarkahoff(tripples, 0, 10);
        for (MarkhoffTripple i : tripples)
            System.out.print(i + " ");
    }

    private static void getMarkahoff(Vector<MarkhoffTripple> tripples, int pos, int n) {
        if (pos == n)
            return;
        MarkhoffTripple t = tripples.get(pos);
        MarkhoffTripple[] follows = t.getFollower();
        for (int i = 0; i < follows.length; i++) {
            if (tripples.size() < n)
                tripples.add(follows[i]);
        }
        pos++;
        getMarkahoff(tripples, pos, n);
    }
Aus den Trippel lassen sich dann die Markhoff Zahlen einfach abbilden.
 

ocsme

Top Contributor
Danke für eure Antworten.
Von Blender verstehe ich fast nix obwohl wir das fast alles hatten ein paar sachen sind neu doch normalerweise sollte ich das mitlerweile besser verstehen können! Denke ich lasse es einfach.

Danke nochmals =)

LG
 

ocsme

Top Contributor
Ja irgendwie hab ich das gefühl egal wieviel ich lerne und Üben tue es klappt einfach nicht! :(

so hab ich es jetzt gemacht:
Java:
public class MarkoffMain {

    static boolean contains(int[] arr, int len, int value) {
        for(int i=0;i<len;i++)
            if(arr[i]==value)
                return true;
        return false;
    }
   
    public static void main(String[] args) {
   
        int n=10;
        int[] a=new int[n*n];
        int pos=0;
        int quersumme=0;
       
        for(int x=1;x<=n;x++)
            for(int y=1;y<=n;y++)
                for(int z=1;z<=n;z++) {
                    if(x*x+y*y+z*z==3*x*y*z) {
                        quersumme=x+y+z;
                       
                           
                        }
                    }
       
        }   
    }


Wie ich jetzt mit der Methode umzugehen habe weis ich auch nicht so recht :(
 

ocsme

Top Contributor
so nun stehen nur noch die Quersummen im Array ;)
Morgen werde ich nun versuchen das sobald eine Quersumme kommt die schon dran war soll er die Zahl nicht Printen! also nochmal durch das Array laufen und vergleichen oder?
Bin grade am Überlegen ob das nicht dann wieder Doppelt gemoppelt ist und ich mal wieder etwas übersehe! Doch heute hab ich mich genug über diese Aufgabe aufgeregt :D Das kann doch nicht so schwer sein :D man man man

Java:
public class MarkoffMain {

    static boolean contains(int[] arr, int len, int value) {
        for(int i=0;i<len;i++)
            if(arr[i]==value)
                return true;
        return false;
    }
  
    public static void main(String[] args) {
  
        int n=100;
        int[] a=new int[n*n];
        int pos=0;
        int quersumme=0;
      
        for(int x=1;x<=n;x++)
            for(int y=1;y<=n;y++)
                for(int z=1;z<=n;z++) {
                    if(x*x+y*y+z*z==3*x*y*z) {
                        quersumme=x+y+z;
                        if(!contains(a,a.length,quersumme)) {
                            a[pos]=quersumme;
                            pos++;
                        }
                      
                      
                        }
                    }
        for(int i=0;i<a.length;i++)
            System.out.println(a[i]);
      
        }  
    }

Okay so läuft es nun danke =)
Java:
public class MarkoffMain {

    static boolean contains(int[] arr, int len, int value) {
        for(int i=0;i<len;i++)
            if(arr[i]==value)
                return true;
        return false;
    }
   
    public static void main(String[] args) {
   
        //16-5000
        int n=8000;
        int[] a=new int[n*n];
        int pos=0;
        int quersumme=0;
        int counter=18;
       
            for(int x=1;x<=n&&counter>0;x++)
                for(int y=1;y<=n&&counter>0;y++)
                    for(int z=1;z<=n&&counter>0;z++) {
                        if(x*x+y*y+z*z==3*x*y*z) {
                            quersumme=x+y+z;
                            if(!contains(a,a.length,quersumme)) {
                                a[pos]=quersumme;
                                pos++;
                                System.out.println(counter+" ("+x+","+y+","+z+")");
                                counter--;
                            }
                        }
                   
        }
           
       
        }   
    }


Problem ist nur ich glaube das funktioniert mit der quersumme nicht so einfach!
Gibt man den Wertebereich n=10.000 und den counter = 50 dann kommen auch Markoff-Zahlen die in Wikipedia auf dem Bild nicht zu sehen sind! :( Kann auch sein das es trozdem Markoff-Zahlen sind und das Bild nicht vollständig ist :D
Habs mal so weit laufen lassen:
50 (1,1,1)
49 (1,1,2)
48 (1,2,5)
47 (1,5,13)
46 (1,13,34)
45 (1,34,89)
44 (1,89,233)
43 (1,233,610)
42 (1,610,1597)
41 (1,1597,4181)
40 (2,5,29)
39 (2,29,169)
38 (2,169,985)
37 (2,985,5741)
36 (5,13,194)
35 (5,29,433)
34 (5,194,2897)
33 (5,433,6466)
32 (13,34,1325)
31 (13,194,7561)
30 (30,5515,8873)
29 (34,89,9077)
28 (98,3175,4635)
27 (175,6369,6447)
26 (203,9331,9858)
25 (215,2643,5058)
24 (217,2617,7601)
23 (229,2434,7745)

In Wikipedia auf dem Bild kommt nach 5.433.6466 gleich 29.433.37666 also entweder klappt es wie gesagt mit der quersumme nicht oder die haben einfach viele nicht dazu genommen. Das mit der Quersumme war ja auch nur ein schneller Einfall von mir und es sollte ein Übung mit Arrays sein die ich nicht hin bekommen habe.

Nochmals Danke =)
 
Zuletzt bearbeitet:

Blender3D

Top Contributor
28 (98,3175,4635)
27 (175,6369,6447)
26 (203,9331,9858)
25 (215,2643,5058)
24 (217,2617,7601)
23 (229,2434,7745)

Die erfüllen die Markhoff Gleichung nicht!
x^2 + y^2 + z^2 = 3*x*y*z
Bei int als Type kann es bei großen Zahlen zu einem Überlauf kommen.
Bei einem 64-Bit System ist es möglich den Zahlenbereich mittels Typ Long zu vergrößern.
Ich habe mir die Lösung von Dir nicht genau angeschaut, aber ein Integer Feld der Größe 8000x8000 = 64.000.000 erscheint mir als unnötig hoher Speicherbedarf. Jedes Markhofftrippel hat genau 3 Nachbarn ( Ausgenommen (1,1,1) 1 Nachbar und ( 1,1,2 ) 2 Nachbarn ).
Meine Lösung verwendet die Berechnung der Nachbarn, um weitere Trippel zu finden. Außerdem würde die Klasse Markhofftrippel einen Fehler werfen, wenn man eine Instanz mit den Falschen Zahlen erstellt. So ist sichergestellt, dass nur gültige Trippel verwendet werden. ( Überlauf ausgenommen. Bei großen Werten Long oder besser BigInteger verwenden )
Schau Dir meine Lösung vielleicht noch einmal an.
 
Zuletzt bearbeitet:

mihe7

Top Contributor

Blender3D

Top Contributor
Hier die Lösung für "beliebig" große Zahlen.
Java:
import java.math.BigInteger;
import java.util.Arrays;

public class MarkhoffTripple implements Comparable<MarkhoffTripple> {
    private BigInteger[] values = new BigInteger[3];

    public MarkhoffTripple(BigInteger x, BigInteger y, BigInteger z) throws IllegalArgumentException {
        values[0] = x;
        values[1] = y;
        values[2] = z;
        setValues(values);
    }

    public MarkhoffTripple(BigInteger[] values) throws IllegalArgumentException {
        setValues(values);
    }

    public MarkhoffTripple() {
        for (int i = 0; i < values.length; i++)
            values[i] = BigInteger.valueOf(1);
        setValues(values);
    }

    @Override
    public int compareTo(MarkhoffTripple o) {
        int cmp = 0;
        for (int i = 2; i > 0; i--) {
            cmp = values[i].compareTo(o.values[i]);
            if (cmp != 0)
                return cmp;
        }
        return cmp;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        MarkhoffTripple other = (MarkhoffTripple) obj;
        if (!Arrays.equals(values, other.values))
            return false;
        return true;
    }

    public BigInteger getCrossSum() {
        return values[0].add(values[1]).add(values[2]);
    }

    public BigInteger[] getValues() {
        return Arrays.copyOf(values, values.length);
    }

    public MarkhoffTripple[] getFollower() {
        MarkhoffTripple[] neigbours = new MarkhoffTripple[2];
        if (getCrossSum().equals(BigInteger.valueOf(3))) {
            neigbours = new MarkhoffTripple[1];
            neigbours[0] = new MarkhoffTripple(BigInteger.valueOf(1), BigInteger.valueOf(1), BigInteger.valueOf(2));
            return neigbours;
        }
        if (getCrossSum().equals(BigInteger.valueOf(4))) {
            neigbours = new MarkhoffTripple[1];
            neigbours[0] = new MarkhoffTripple(BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(5));
            return neigbours;
        }
        BigInteger x = values[1];
        BigInteger y = values[2];
        BigInteger z = values[0];
        neigbours[1] = new MarkhoffTripple(x, y, BigInteger.valueOf(3).multiply(x).multiply(y).subtract(z));
        x = values[0];
        y = values[2];
        z = values[1];
        neigbours[0] = new MarkhoffTripple(x, y, BigInteger.valueOf(3).multiply(x).multiply(y).subtract(z));
        return neigbours;

    }

    public static boolean isMarkhoffTripple(BigInteger x, BigInteger y, BigInteger z) {
        BigInteger sum1 = x.multiply(x).add(y.multiply(y)).add(z.multiply(z));
        BigInteger sum2 = BigInteger.valueOf(3).multiply(x).multiply(y).multiply(z);
        return sum1.equals(sum2);
    }

    private void setValues(BigInteger[] values) {
        if (values == null || values.length != 3 || !isMarkhoffTripple(values[0], values[1], values[2]))
            throw new IllegalArgumentException("No Markhofftripple!");
        this.values = Arrays.copyOf(values, values.length);
        Arrays.sort(this.values);
    }

    @Override
    public String toString() {
        return "[" + values[0] + ", " + values[1] + ", " + values[2] + "]";
    }
Java:
public static void main(String[] args) {
        Vector<MarkhoffTripple> tripples = new Vector<MarkhoffTripple>();
        tripples.add(new MarkhoffTripple());
        getMarkahoff(tripples, 0, 15);
        MarkhoffTripple[] t = new MarkhoffTripple[tripples.size()];
        t = tripples.toArray(t);
        Arrays.sort(t);
        int num = 0;
        for (MarkhoffTripple i : t) {
            System.out.println(++num + "\t" + i);
        }
    }

    private static void getMarkahoff(Vector<MarkhoffTripple> tripples, int pos, int max) {
        if (pos == max)
            return;
        MarkhoffTripple t = tripples.get(pos);
        MarkhoffTripple[] follows = t.getFollower();
        for (int i = 0; i < follows.length; i++) {
            if (tripples.size() < max)
                tripples.add(follows[i]);
        }
        pos++;
        getMarkahoff(tripples, pos, max);
    }
 
X

Xyz1

Gast
@Blender3D :eek:
Das heißt nicht ich möchte in Schwierigkeiten geraten. :confused:

Aber ich stimme auch zu, praktisch sollte ein nicht absehbarer Wertebereich nicht von belang sein. ;)
 

mihe7

Top Contributor
Oh, Mist, die Pyramide der Illuminaten; in Form eines Dreiecks... und ich denke mir die ganze Zeit, wie kommt der Markoff nur auf den Faktor 3?
 

ocsme

Top Contributor
Danke nochmals an euch alle :)
Das ist echt super Nett. Weiß auch nicht was gestern wieder los war.
Sitze jetzt 20 Minuten in der Mensa und hab es so hinbekommen mit der Quersumme ins Array zu schreiben:
Java:
public class MarkoffZwei {
    public static void main(String[] args) {
       
        int n=100;
        int quersumme=0;
        int[] a=new int[n];
        int pos=0;
        int tmp=pos;
        int i=0;
       
       
        for(int x=1;x<=n;x++)
            for(int y=1;y<=n;y++)
                for(int z=1;z<=n;z++)
                    if(x*x+y*y+z*z==3*x*y*z) {
                        quersumme=x+y+z;
                        tmp=pos;
                        i=0;
                        boolean u=true;
                        boolean abbruch=false;
                        while(!abbruch&&tmp>=0) {
                           
                            if(a[i]==0)
                                a[i]=quersumme;
                            if(a[i]!=quersumme) {
                                i++;
                                u=false;
                            }
                            if(a[i]==quersumme)
                                abbruch=true;
                            if(u)
                             i++;
                             tmp--;
                        }
                        pos++;
                    }
        for(int k=0;k<a.length;k++)
            System.out.println(a[k]);
    }

}

Nein es ist nicht schön aber es klappt die Quersummen stehen alleine in meinem Array drin =)
Natürlich fehlen dann noch das abgleichen der Markoff Zahlen das mache ich vielleicht nochmal später doch ich finde den ansatz mit der Method von dir Mihe7 besser ;)

Das ganze von Blender ist KLASSE nur sei mir bitte nicht böse doch ich verstehe das aller meiste davon nicht! :( Trozdem ein super Liebes Dank dafür =)
 

ocsme

Top Contributor
So hab nun zwei Klassen geschrieben und es so gemacht.
Vielleicht hat ja noch jemand ein paar Verbesserungsvorschläge würde mich freuen :)

Das mit der Quersumme ist auch nicht so ganz Korrekt aber ich laufe ja nur bis zu den ersten 20 Zahlen die stimmen alle noch :) hehe!

Hier mal die Klasse MarkokffMain:
Java:
public class MarkoffMain {

    static void findMarkoff(int n) {
        Tripel t = new Tripel();
        t.findMarkoff(n);
    }
   
    public static void main(String[] args) {
        int eingabe=Integer.parseInt(args[0]);
        findMarkoff(eingabe);
        }   
    }

und die Klasse Tripel:
Java:
public class Tripel {
    int x, y, z;
    //int[][][] Tripel = new int[20][20][20];
   
    Tripel(int x, int y, int z){
        this.x=x;
        this.y=y;
        this.z=z;
    }
   
    Tripel(int x, int y) {
        this(x,y,0);
    }
   
    Tripel(int x) {
        this(x,0);
    }
   
    Tripel(){
        this(0);
    }
   
    int getX() {
        return x;
    }
   
    int getY() {
        return y;
    }
   
    int getZ() {
        return z;
    }
   
    boolean contains(int[] arr, int len, int value) {
        for(int i=0;i<len;i++)
            if(arr[i]==value)
                return true;
        return false;
    }
   
    void findMarkoff(int eingabe) {
        int n=0, counter=0;
        boolean go=true;
       
        if(eingabe<=0) {
            System.out.println("Die Eingegebene Markoff Zahl "+eingabe+" existiert nicht!");
            go=false;
        }
        if(go)
        switch(eingabe) {
        case 1:     {n=1;counter=1;}        break;
        case 2:     {n=4;counter=2;}         break;
        case 3:     {n=8;counter=3;}        break;
        case 4:     {n=20;counter=4;}        break;
        case 5:     {n=50;counter=5;}        break;
        case 6:     {n=125;counter=6;}        break;
        case 7:     {n=325;counter=7;}        break;
        case 8:     {n=845;counter=8;}        break;
        case 9:     {n=1000;counter=9;}        break;
        case 10:     {n=1000;counter=10;}    break;
        case 11:    {n=1000;counter=11;}    break;
        case 12:    {n=1000;counter=12;}    break;
        case 13:    {n=1160;counter=13;}    break;
        case 14:    {n=6730;counter=14;}    break;
        case 15:    {n=7700;counter=15;}    break;
        case 16:    {n=7700;counter=16;}    break;
        case 17:    {n=7700;counter=17;}    break;
        case 18:    {n=7700;counter=18;}    break;
        case 19:    {n=7700;counter=19;}    break;
        case 20:    {n=7770;counter=20;}    break;
        default:     counter=eingabe;         break;
        }
       
        int[] a=new int[n];
        int i=1, pos=0, quersumme=0;
       
        if(counter>20) {
            System.out.println("Die geforderte Markoff-Zahl "+counter+" ist zu gross um sie in "
                    +"vernuenftiger Zeit berrechnen zu koennen!");
            go=false;
        }
   
            if(go)
            for(int x=1;x<=n&&counter>0;x++)
                for(int y=1;y<=n&&counter>0;y++)
                    for(int z=1;z<=n&&counter>0;z++) {
                        if(x*x+y*y+z*z==3*x*y*z) {
                            quersumme=x+y+z;
                            if(!contains(a,a.length,quersumme)) {
                                a[pos]=quersumme;
                                pos++;
                                Tripel t = new Tripel(x,y,z);
                                System.out.println(t.toString());
                                counter--;
                                i++;
                            }
                        }
                    }   
    }
   
    public String toString() {
        return "("+getX()+","+getY()+","+getZ()+")";
    }

}
 

mihe7

Top Contributor
Ohne mir das jetzt näher angesehen zu haben: das switch kannst Du Durch Arrays ersetzen. Außerdem kannst Du die Methode in kleinere aufdröseln.
 

ocsme

Top Contributor
Wie immer super schnelle und Liebe Antwort.
Werde ich mir gedanken machen und mich wieder melden :)
Übung macht den Meister habe ich recht :)
LG
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
ixChronos Letzten 4 Ziffern einer großen Zahl ausgeben Java Basics - Anfänger-Themen 3
T Ich brauche eine Schleife die eine beliebige Zahl so lange durch 10 teilt bis zur Null Java Basics - Anfänger-Themen 5
Shadowrunner Variablen Gibt es eine Möglichkeit die Ziffern/Stellen einer Zahl fest zu legen? Java Basics - Anfänger-Themen 3
T float soll durch schleife die größte mögliche Zahl herausfinden, Ausgabe ist aber "Infinity" Java Basics - Anfänger-Themen 1
T Eingabe durch eine Zahl dividieren nachgucken? Java Basics - Anfänger-Themen 4
G Bei dynamischer Arrayliste nach jeder Auswahl Zahl entfernen Java Basics - Anfänger-Themen 3
M Long-Typ in String-Änderung führt zu keinem Ergebnis bei großer Zahl Java Basics - Anfänger-Themen 11
E Array, nächste Zahl zur 5 ausgeben, wie? Java Basics - Anfänger-Themen 42
A Methoden Guten Tag , ich wollte so machen dass wenn meine frog an eine fly/bee geht dann an meine Tafel geht der zahl +1 hoch. Java Basics - Anfänger-Themen 2
B Überprüfung dass Zahl nur aus 0,1 besteht Java Basics - Anfänger-Themen 2
S Vollkommene Zahl berechnen und ausgeben Java Basics - Anfänger-Themen 16
B Hashmap richtig bauen, die Tripel auf Zahl abbildet? Java Basics - Anfänger-Themen 10
S Größte Zahl nach Eingabe der Zahl 0 ausgeben Java Basics - Anfänger-Themen 6
B 49-bit-zahl mit genau 6 Einsen bauen? Java Basics - Anfänger-Themen 21
D Kleinste Zahl in Array finden die vorher noch errechnet werden müssen. Java Basics - Anfänger-Themen 4
M Java Ausgabe der höchsten Zahl Java Basics - Anfänger-Themen 14
Thomas06 Wie kann man mithilfe von boolean herausfinden ob eine zahl durch 5 und 7 teilbart ist ? Java Basics - Anfänger-Themen 7
M Prüfen on eine Zahl im String enthalten ist Java Basics - Anfänger-Themen 3
M zahl raten Java Basics - Anfänger-Themen 1
G Position einer unbekannten 3-stelligen-Zahl in einem String finden Java Basics - Anfänger-Themen 15
sserio Prüfen, ob eine Zahl eine periodische Zahl ist Java Basics - Anfänger-Themen 20
H Erste Schritte Nach einer Zahl n soll n Mal der String untereinander ausgegeben werden Java Basics - Anfänger-Themen 3
I Zahl aufrunden (Zeit) Java Basics - Anfänger-Themen 43
M Eine Methode die erkennt ob die ein gegebene zahl größer oder kleiner sein muss Java Basics - Anfänger-Themen 2
D Gerade oder ungerade Zahl mittels Methoden Java Basics - Anfänger-Themen 13
TanTanIsTrying Durschnitt berechnen von eingegebener Zahl bis 1 heruntergezählt Java Basics - Anfänger-Themen 9
R Fortlaufende Zahl Java Basics - Anfänger-Themen 3
A Wenn eine Zahl durch 7 teilbar ist, soll statt der Zahl ein ‘*‘ angezeigt werden. java? Java Basics - Anfänger-Themen 47
K Warum gibt mir z. B. 40^128 eine Zahl? Ich dachte mit xor kann man nur booleanwerte erhalten, also prüfen ob etwas whar oder falsch ist? Java Basics - Anfänger-Themen 1
I String Kombination erstellen anhand fortlaufender Zahl (Vertragsnummer) Java Basics - Anfänger-Themen 13
B Methoden Rekursiv festellen, ob eine Zahl gerade-oft vorkommt oder nicht Java Basics - Anfänger-Themen 4
W Wie ziehe ich von einer bestimmten Zahl, Zahlen ab, bis mein Ergebnis null beträgt? Java Basics - Anfänger-Themen 10
Q Prüfen ob Zahl als Summe von Potenzen dargestellt werden kann. Java Basics - Anfänger-Themen 20
HelpInneed Zahl. Java Basics - Anfänger-Themen 2
R Perfekte Zahl Java Basics - Anfänger-Themen 8
D Mittlerste Zahl Java Basics - Anfänger-Themen 17
D Grösste Zahl in einer Folge herausfinden. (ULAM) Java Basics - Anfänger-Themen 9
Poppigescorn Häufigkeit einer zahl zählen Java Basics - Anfänger-Themen 5
B Konkatenieren eines Strings und inkremtierenden Zahl zu einer INT Variablen Java Basics - Anfänger-Themen 7
Poppigescorn scan.nextInt() wiederholen bis eine Zahl eingeben wird Java Basics - Anfänger-Themen 7
J Verdoppeln einer Zahl (in dem Fall Münzen) Java Basics - Anfänger-Themen 4
C Programm das feststellen kann, ob eine eingegebene Zahl einem Schaltjahr entspricht, richtig geschrieben? Java Basics - Anfänger-Themen 11
S Algorithmus (reelle Zahl <65536 von dezimal zu dual) max. 10 Nachkommastellen Java Basics - Anfänger-Themen 4
K Wie kontrolliere ich ob ich die Zahl in meinem Array schon hab? Java Basics - Anfänger-Themen 9
T Zahl in Array ersetzen Java Basics - Anfänger-Themen 2
Abraham42 Prozentsatz einer Zahl mehrmals Java Basics - Anfänger-Themen 2
C Größte Zahl aus einem Array ermitteln(als statische Methode) Java Basics - Anfänger-Themen 31
Kingamadeus2000 Anzahl der Ziffern der kürzesten Zahl aus einem zurückliefern Java Basics - Anfänger-Themen 1
V Beliebige Dreistellige Zahl Teiler finden Java Basics - Anfänger-Themen 4
newcomerJava Nach doppelter Zahl eine Ausgabe Java Basics - Anfänger-Themen 10
W Random Zahl unter Berücksichtung eines Durchschnitts Java Basics - Anfänger-Themen 7
S Zahl eingeben Java Basics - Anfänger-Themen 8
A Java . punkt neben einer Zahl. Java Basics - Anfänger-Themen 1
F Eine Zahl mit Arrays vergleichen Java Basics - Anfänger-Themen 7
J Die größte Zahl anzeigen Java Basics - Anfänger-Themen 19
V Array auf eine Zahl durchsuchen Java Basics - Anfänger-Themen 15
X Nach einem Bruch testen ob es eine ganze Zahl ist Java Basics - Anfänger-Themen 6
L Erhöhung der Zahl Java Basics - Anfänger-Themen 3
F Negative Zahl erzwingen Java Basics - Anfänger-Themen 3
N Eine Zahl solange teilen bis es nicht möglich ist und die Ergebnisse ausgeben Java Basics - Anfänger-Themen 23
T Eulersche Zahl e Java Basics - Anfänger-Themen 5
S Letzte Zahl eines Integer auslesen? Java Basics - Anfänger-Themen 3
G Programm schreiben: Zahl (n) eingeben, 1+1/n+2/n+3/n+....+n/n Java Basics - Anfänger-Themen 8
B Eine ganze Zahl zerlegen. Java Basics - Anfänger-Themen 4
J Fehler beim generieren von 4 Zufallszahlen Zahl doppelt ist eigentlich ausgeschlossen Java Basics - Anfänger-Themen 9
H Harshad-Zahl (Nivenzahl) und Palindrom überprüfen Java Basics - Anfänger-Themen 2
I Wie viele 1 an Bits hat die Zahl x? Java Basics - Anfänger-Themen 5
A Gewürfelte Zahl ausgeben Java Basics - Anfänger-Themen 10
M Rationale Zahl erkennen - Kurze Frage zum Restwert nach Division Java Basics - Anfänger-Themen 3
A Überprüfen, ober eine Zahl Ziffer enthält Java Basics - Anfänger-Themen 12
B Datenbank, aktuelle Ende als Zahl an Label übergeben Java Basics - Anfänger-Themen 7
L 10-Stellige Zahl hochzählen lassen Java Basics - Anfänger-Themen 1
H String und Zahl Java Basics - Anfänger-Themen 10
R Zahl 1 bis 100 erraten Java Basics - Anfänger-Themen 12
Y Konkrete Hilfe gesucht - Anzahl der Stellen einer eingegebenen Zahl überprüfen Java Basics - Anfänger-Themen 5
J Button klick bei eine bestimmten Zahl Java Basics - Anfänger-Themen 8
B Zahl in String abspeichern und später berechnen Java Basics - Anfänger-Themen 15
H OOP eine Zahl immer weiter durch 2 teilen Java Basics - Anfänger-Themen 15
J Für jeden Buchstaben eine Zahl Java Basics - Anfänger-Themen 1
H Würfelspiel, stop bei gleicher Zahl Java Basics - Anfänger-Themen 4
B Array - die Häufigkeit der Zahl zählen Java Basics - Anfänger-Themen 9
I Erste Schritte Testen, ob eine Zahl eine Primzahl ist Java Basics - Anfänger-Themen 8
J Rekursive Methode - Ziffern einer Zahl ausgeben Java Basics - Anfänger-Themen 2
I Eulersche Zahl Java Basics - Anfänger-Themen 6
F Produkt d. Ziffern einer Zahl..?! Java Basics - Anfänger-Themen 5
J Die Zahl herausfinden die durch 2 - 30 Teilbar ist... Java Basics - Anfänger-Themen 17
A Ungeordnetes Array ordnen, Zahl einlesen und einordnen Java Basics - Anfänger-Themen 23
A Rechnen mit Text und Zahl Java Basics - Anfänger-Themen 4
T Datentypen char als Buchstaben statt als Zahl ausgeben Java Basics - Anfänger-Themen 4
S Jede Ziffer einer Zahl auslesen, damit rechnen und beim Ergebnis wiederholen ? Java Basics - Anfänger-Themen 20
H 32-Bit Zahl (Integer) in eine IPv4 Adresse umwandeln? Java Basics - Anfänger-Themen 2
Aprendiendo Gibt es in der JAVA-API eine Funktion, die eine Dezimalzahl in eine binäre Zahl umwandelt? Java Basics - Anfänger-Themen 8
M Mit 2 Threads eine Zahl hochzählen Java Basics - Anfänger-Themen 13
D String erste Zahl mit LKZ auslesen lassen Java Basics - Anfänger-Themen 36
C Erste Ziffer einer Zahl Java Basics - Anfänger-Themen 46
M Zeilenumbruch ab der 10. Zahl Java Basics - Anfänger-Themen 11
T Input/Output Int Eingabe auf Zahl überprüfen Java Basics - Anfänger-Themen 30
R Input/Output zahl aus showInputDialog() Java Basics - Anfänger-Themen 25
D Die Zahl in der Mitte finden Java Basics - Anfänger-Themen 20
S Rekursives Zählen einer Zahl Java Basics - Anfänger-Themen 8

Ähnliche Java Themen

Neue Themen


Oben