Methoden BinaryStrings vergleichen

[joypolite]

Hallo,
ich habe leider Probleme damit BinaryStrings miteinander zu vergleichen (größer, kleiner).
Die Aufgabe lautet so, dass man zwei Zahlen einlesen, diese dann in Binärform umwandeln und vergleichen soll ( Bei zwei Nullen soll das Programm beendet werden). Einscannen und umwandeln hat geklappt (siehe Quellcode). Leider hab ich null Ahnung wie ich die Strings vergleichen soll. Ich soll auch noch ausgeben nach welchem Iterationsschritt der Vergleich abbricht.

Ich würde mich sehr über eure Hilfe freuen

import java.util.Scanner;

public class binaryVergleich {
   
    public static void main (String[] args) {
       
        while (true){
           
            Scanner s = new Scanner(System.in);
            int a = s.nextInt();
            int b = s.nextInt();
            int summe = a+b;
       
       
       
            if (summe == 0){
                break;
            }else{
                String c = Integer.toBinaryString(a);
                String d = Integer.toBinaryString(b);
       
                System.out.println("a= "+a+" binaer: "+c);
                System.out.println("b= "+b+" binaer: "+d);
            }
       
       

       
        }
    }
}

 

[Robat]

Wie sollst du sie denn vergleichen? Stelle für Stelle?

 

[Javinner]

@youpolite
https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#equals-java.lang.Object-

Spoiler: public final class String : Originalcode

/**
     * Compares this string to the specified object.  The result is {@code
     * true} if and only if the argument is not {@code null} and is a {@code
     * String} object that represents the same sequence of characters as this
     * object.
     *
     * @param  anObject
     *         The object to compare this {@code String} against
     *
     * @return  {@code true} if the given object represents a {@code String}
     *          equivalent to this string, {@code false} otherwise
     *
     * @see  #compareTo(String)
     * @see  #equalsIgnoreCase(String)
     */
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

edit: obwohl die Classe String von Comparable<T> erbt, ist die Methode compareTo() anders ausgelegt und liefert nur Wahrheitswerte.
So wirst du nicht drum rum kommen, eine eigene Methode für den kleiner/größer Vergleich zu schreiben. Schau dir am besten in der JDK deiner Wahl die Klasse String als Code an.

 

[Javinner]

Überlege dir, wie die Methode compareTo(String a, String b) aussehen könnte?
Soviel sei schon verraten: die Länge des jeweiligen Strings spielt eine entscheidende Rolle.

int zahlA = 100;
int zahlB = 101;

int zahlC = 101;
int ZahlD = 100;

int zahlE = 100;
int zahlF = 100;

String stringA = Integer.toBinaryString(zahlA);
String stringB = Integer.toBinaryString(zahlB);
String stringC = Integer.toBinaryString(zahlC);
String stringD = Integer.toBinaryString(ZahlD);
String stringE = Integer.toBinaryString(zahlE);
String stringF = Integer.toBinaryString(zahlF);

System.out.println(compareTo(stringA, stringB));
System.out.println(compareTo(stringC, stringD));
System.out.println(compareTo(stringE, stringF));

/** Konsolenausgabe */
-1
1
0

 

[joypolite]

@Javinner

Genau, ich habe jetzt versucht meinen Code so zu erweitern, dass die Strings die gleiche Länge haben. Es sollte ja dann Bitweise anfangen die Strings zu vergleichen. D.h. dass es dann klüger wäre von links nach rechts die Strings zu vergleichen (bei dem höchsten Bit starten).
Ich habe mir überlegt eine For-schleife zu machen und dann beim höchsten Bit (in dem Fall x) anfangend beide Strings zu durchlaufen und zu vergleichen. Ergibt das einen Sinn?

import java.util.Scanner;

public class a1 {
   
   
    public static void main (String[] args) {
       
        while (true){
           
            Scanner s = new Scanner(System.in);
            int a = s.nextInt();
            int b = s.nextInt();
            int summe = a+b;
            int x;
       
       
       
            if (summe == 0){
                break;
            }else{
                String c = Integer.toBinaryString(a);
                String d = Integer.toBinaryString(b);
       
                System.out.println("a= "+a+" binaer: "+c);
                System.out.println("b= "+b+" binaer: "+d);
               
               
               
                if ( c.length() < d.length()){
                    x = d.length();
                }if (c.length() < d.length()){
                    x = c.length();
                }else{
                    x = c.length();
                }
                   
               
                while (c.length() < x) {
                    c+= "0";
                }
               
                while (d.length() < x) {
                    d+= "0";
                }
               
                System.out.println(c);
                System.out.println(d);
            }
        }
    }
}

 

[Javinner]

Ich würde zuerst prüfen, ob die Werte gleich lang sind.
Beispiel:

int a = 100;
int b = 111;
System.out.println(Integer.toBinaryString(a).length());
System.out.println(Integer.toBinaryString(b).length());
/** Konsolenausgabe */
7
7

Was schließen wir daraus?
Richtig, die "längere" Zahl ist somit die größere. So haben wir doch schon zweidrittel aller Möglichkeiten im Sack.

if(a.length > b.length)
{
     return 1;
} else if(a.length < b.length)
{
      return - 1;
} else
{
     //Dein Code
}

So musst du dir jetzt nur überlegen, wie du die "gleich" Bedingung umsetzt.
Hier gibt es mehrere Wege. Natürlich der einfachere: die Werte zu Integer umwandeln und vergleichen,
dies ist aber mit Sicherheit nicht die Aufgabenstellung. Also musst du Wert um Wert vergleichen.
Wo du dabei beginnen solltest?
Ein Beispiel:

for (int i = 0; i < 10; i++) {
     System.out.println("Binär: " + Integer.toBinaryString(i) + ", Zahl: " + i);
}
/** Konsolenausgabe */
Binär: 0, Zahl: 0
Binär: 1, Zahl: 1
Binär: 10, Zahl: 2
Binär: 11, Zahl: 3
Binär: 100, Zahl: 4
Binär: 101, Zahl: 5
Binär: 110, Zahl: 6
Binär: 111, Zahl: 7
Binär: 1000, Zahl: 8
Binär: 1001, Zahl: 9

Was fällt dir auf?

 

[Javinner]

ich habe leider Probleme damit BinaryStrings miteinander zu vergleichen (größer, kleiner).

Interface Comparable<T> : https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html?is-external=true

Wenn wir als Beispiel die Wrapper-Klasse Integer nehmen, welche das Interface Comparable implementiert, so stellen wir fest, dass die Methode compareTo folgend umgesetzt wird:

public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}    
public static int compare(int x, int y) {
     return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

Dabei fällt auf, dass hier drei Werte: 1, -1 und 0 geliefert werden. Also empfehle ich dir dringend, deine Werte nach dem gleichen Prinzip zu vergleichen, so dass bei einer Vergleichsmethode ebenso die
Werte 1, -1 und 0 als Vergleichswerte geliefert werden.

 

[joypolite]

@Robat @Javinner
Ich glaube ich habe die Aufgabe falsch erklärt.
Aufgabe
1. zwei positive Dezimalzahlen sollen eingelesen werden (bei der Eingabe von "0 0" soll das Programm beendet werden)
2. Dezimalzahlen sollen in Binärform umgewandelt und ausgegeben werden
3. Beide Binärstrings sollen verglichen werden und ausgegeben werden welche Zahl größer ist (bzw ob beide Zahlen gleich sind), dafür soll man Schritt für Schritt jedes Bit vergleichen und bei dem "ausschlaggebendem" Bit abbrechen und ausgeben bei welchem Bit abgebrochen worden ist.

1. und 2. habe ich umgesetzt. Danach habe ich beide Strings auf die gleiche Länge gebracht (also den kürzeren String mit 0 aufgefüllt)
Um nun bitweise zu vergleichen habe ich die Strings in Int Arrays umgewandelt.
ABER bei den Testzahlen (12345 und 12346) kommt bei mir das falsch raus.

Die Ausgabe soll laut Aufgabe so aussehen:


Und das ist meine Ausgabe:

import java.util.Scanner;

public class a1 {
 
 
    public static void main (String[] args) {
     
        while (true){
         
            Scanner s = new Scanner(System.in);
            int a = s.nextInt();
            int b = s.nextInt();
            int summe = a+b;
            int x;
     
     
     
            if (summe == 0){                                          // bricht bei 0 0 ab
                break;
            }else{
                String c = Integer.toBinaryString(a);                 // Umwandlung in Binärform
                String d = Integer.toBinaryString(b);
     
                System.out.println("a= "+a+" binaer: "+c);
                System.out.println("b= "+b+" binaer: "+d);
             
             
             
                if ( c.length() < d.length()){                            //Ermittlung des längeren Strings
                    x = d.length();
                }if (c.length() < d.length()){
                    x = c.length();
                }else{
                    x = c.length();
                }
                 
             
                while (c.length() < x) {                                 // auffüllen des kürzeren Strings mit 0
                    c+= "0";
                }
             
                while (d.length() < x) {
                    d+= "0";
                }
             
             
                String[] cArr = c.split("");                            // Umwandlung der Binärstrings in StringArrays
                String[] dArr = d.split("");
             
                int[] cArrayint = new int[cArr.length];                    //Umwandlung der StringArrays in IntegerArrays
                for (int i = 0; i < cArr.length; i++) {
                    cArrayint[i] = Integer.parseInt(cArr[i]);
                }

                int[] dArrayint = new int[dArr.length];         
                for (int i = 0; i < dArr.length; i++) {
                    dArrayint[i] = Integer.parseInt(dArr[i]);
                }
             
             
                for (int j=x-1; j>=0; j--){                                // Integerarrays vergleichen
             
                    if(cArrayint[j] == dArrayint[j]){
                     
                        if(j==0){
                            System.out.println("a=b");
                            break;
                        }else{
                            continue;
                        }
                    }if (cArrayint[j] > dArrayint[j]){
                        System.out.println("a>b -- Abbbruch bei Bit "+j);
                        break;
                    }else{
                        System.out.println("b>a -- Abbbruch bei Bit "+j);
                        break;
                    }
                }
             


            }
        }
    }
}

 

[Robat]

Ich soll auch noch ausgeben nach welchem Iterationsschritt der Vergleich abbricht.

Die Aussage würde ich so verstehen, dass man sagt bei welchem Bit sich die beiden Strings unterscheiden. Somit würden Dinge wie equals oder compare wegfallen.

Edit: ups zu spät.

 

[Javinner]

In etwa so?

int a = 999999999;
int b = 999999999;

int c = 999999998;
int d = 999999999;

int e = 999999999;
int f = 999999899;

String stringA = Integer.toBinaryString(a);
String stringB = Integer.toBinaryString(b);
String stringC = Integer.toBinaryString(c);
String stringD = Integer.toBinaryString(d);
String stringE = Integer.toBinaryString(e);
String stringF = Integer.toBinaryString(f);
System.out.println();
System.out.println("String A: " + stringA + ", String A Länge: " + stringA.length());
System.out.println("String B: " + stringB + ", String B Länge: " + stringB.length());
System.out.println(compareTo(stringA, stringB));
System.out.println();
System.out.println("String C: " + stringC + ", String C Länge: " + stringC.length());
System.out.println("String D: " + stringD + ", String D Länge: " + stringD.length());
System.out.println(compareTo(stringC, stringD));
System.out.println();
System.out.println("String E: " + stringE + ", String E Länge: " + stringE.length());
System.out.println("String F: " + stringF + ", String F Länge: " + stringF.length());
System.out.println(compareTo(stringE, stringF));

/** Konsolenausgabe */
String A: 111011100110101100100111111111, String A Länge: 30
String B: 111011100110101100100111111111, String B Länge: 30
0

String C: 111011100110101100100111111110, String C Länge: 30
String D: 111011100110101100100111111111, String D Länge: 30
Position: 1
-1

String E: 111011100110101100100111111111, String E Länge: 30
String F: 111011100110101100100110011011, String F Länge: 30
Position: 7
1
/** Zaehlt man die Bits nicht von Rechts nach Links? */

 

[Javinner]

int a = 999999999;
int b = 999999999;

int c = 999999998;
int d = 999999999;

int e = 999999999;
int f = 999999989;

String A: 111011100110101100100111111111, String A Länge: 30
String B: 111011100110101100100111111111, String B Länge: 30
0

String C: 111011100110101100100111111110, String C Länge: 30
String D: 111011100110101100100111111111, String D Länge: 30
Position: 1
-1

String E: 111011100110101100100111111111, String E Länge: 30
String F: 111011100110101100100111110101, String F Länge: 30
Position: 2
1

 

[joypolite]

Ich habs nun habe es doch komplett anders gemacht. So klappt es aber.

import java.util.Scanner;

public class a_1{
   
    public static void main (String[] args) {
       
        while (true){
            Scanner s = new Scanner(System.in);
            System.out.print("Eingabe: ");
            int a = s.nextInt();
            int b = s.nextInt();       
            int summe= a+b;
           
            if ( summe == 0){
                System.out.println("Programmende");
                break;
            }else{
               
                System.out.println("a= "+a+" binaer: "+Integer.toBinaryString(a));
                System.out.println("b= "+b+" binaer: "+Integer.toBinaryString(b));
                int n = 30;
                while (n >= 0){
               
                    int x= 1<<n;
               
                    int aBit = a & x;
                    int bBit = b & x;
               
                    if (aBit == bBit){
                        n--;
                        if (n<0){
                            System.out.println("a=b");
                        }
                        continue;
                       
                    }else{
                        if (aBit != 0){
                            System.out.println("a>b -- Abbruch bei Bit "+n);
                        }else{
                            System.out.println("b>a -- Abbruch bei Bit "+n);
                        }
                        break;
                    }
                   
               
                }
               
            }
                           
           
        }
       
       
    }
   
}

 

[Javinner]

Nur vergleichst du keine Strings Soll die Leistung aber nicht schmälern.