# Unicode umrechnen



## puschelemo21 (26. Okt 2011)

Hallo,
ich bins nochmal.
also mein Code:

```
public class Aufg3a3 {
   public static void main(String[] args) throws Exception {
   char zeichen1 =(char) System.in.read();
//   System.out.println(zeichen1);

   char zeichen2 =(char)System.in.read();
   //System.out.println(zeichen2);

   int zeichen3 =(int)System.in.read();
   //System.out.println(zeichen3);

   int zeichen4 =(int) System.in.read();
  // System.out.println(zeichen4);

   int zeichen5 =(int)System.in.read();
  // System.out.println(zeichen5);

   int zeichen6 =(int)System.in.read();
  // System.out.println(zeichen6);
   
//   
   
   if (! (zeichen1=='/')){
     System.out.println("Falsche Angabe");
     return;
   }
   if (! (zeichen2=='u')){
     System.out.println("Falsche Angabe");
     return;
   }
   if (! (zeichen3=='0')){
     System.out.println("Falsche Angabe");
     return;
   }
   if (!(zeichen4>='a'&& zeichen4<='f' || zeichen4>='0' && zeichen4<='9' )){
      System.out.println("Das vierte Zeichen ist falsch");
      }
   if (!(zeichen5>='a'&& zeichen5<='f' || zeichen5>='0' && zeichen5<='9' )){
      System.out.println("Das fünfte Zeichen ist falsch");
      }
   if (!(zeichen6>='a'&& zeichen6<='f' || zeichen6>='0' && zeichen6<='9' )){
      System.out.println("Das letzte Zeichen ist falsch");
      }


//      System.out.println("dezimaler Wert: " + );
//      System.out.println("hexadezimaler Wert: " + Integer.toHexString());
//      System.out.println("Char: " + );
```
ich muss nun die Werte umrechnen das z.b. Unicode:/u0041 in hex: 0041, dez: 65, char: A  ausgegebn werden kann ich weis nur nicht wie ich die 6 Werte nun zusammennehme und dann sag du bist eine einzige Variable nun umwandeln in system.out.?!
Hoffe ihr könnt mir nochmals nen Denkanstoß geben


----------



## Andi_CH (26. Okt 2011)

1. fehlen returns - immer nachdem du einen Fehler festgestelt hast -> return

2. machst du aus den eingelesenen Werten int und vergleichst danach mit Buchstaben -> technisch geht das zwar, aber es zeugt nicht gerade von gutem Typenverständnis -> Egal Java lässt es zu.

3. Wie machst du denn im Kopf oder auf dem Papier aus den Ziffern 1 2 4 2 die Zahl 1242? -> Genau so geht das in einem Programm

4. System.out.prinln:

```
int i = 42;
		System.out.println("So einfach kann das Leben sein : " + i);
```


----------



## puschelemo21 (26. Okt 2011)

okay alles geändert aber die nummer 3 die du beschrieben hast hm keine Ahnung wenn ichs aufs Blatt machen würd 


zahl=1;
zahl2=2;


ergebnis zahl &zahl2


----------



## Andi_CH (26. Okt 2011)

int ziffer1 = 4
int ziffer2 = 2

int resultat = ??? // das muss 42 sein - wie kommt man mit *ganz normalem rechnen* da drauf?

What the hell soll & für ein Operator sein - ich habe den im Matheunterrich nirgends gesehen.

Ach noch was - unicode zahlen sind IMO nicht HEX sondern nur dezimal oder nicht? (Das war eine echte Frage)


----------



## puschelemo21 (26. Okt 2011)

sorry das ich gefragt hab -.- dann lass es bleiben. vll kanns mir jemand anderes erklären danke.


----------



## Andi_CH (26. Okt 2011)

Hallooooooooooooo - ich geb dir sicher nicht die Lösung

Wie kommt man von 

Ziffer1 = 4
Zifer2 = 2

auf 42?


----------



## puschelemo21 (26. Okt 2011)

Indem man die " variablen zusammenfügt wie sonst
p.s. spar dir solche s****** anmachen bei Neulinge verdirbst eh nur den spaß!


----------



## Andi_CH (26. Okt 2011)

Zusammenfügt - rechne den Wert aus - Programmieren beginnt *immer* auf dem Papier - wie rechnest du das aus?

Wie wärs mit 4 * 10 + 2 ?

Oder wenn es denn Hex sein müsste (was ich bezweifle) 4 * 16 + 2 ?


----------



## puschelemo21 (26. Okt 2011)

garnich?
weil ich die Zahlen nebeneinander schreib un gut is! ES GIBT an der STELLE keine Berechnung.


----------



## Andi_CH (26. Okt 2011)

Es gibt sehr wohl eine Berechnung - Java kann keine "Zahlen nebeneinander schreiben" Mathe auch nicht

42 = 4 * 10 + 2


1 2 3 4 = 1 * 1000 + 2 * 100 + 3 * 10 + 4

So gehts und das solltest du jetzt implementieren


```
int resultat = 0;
for (int i=2; i>6; i++)  { // Die ersten zwei Zeichen sind ja /u
  resultat mit 10 Multiplizieren
  wert der an stelle i im String steht dazuzählen
}
sysout resultat;
```


----------



## Firephoenix (26. Okt 2011)

Edit: Andi war schneller 
Doch gibt es,
entweder du ließt die chars ein und rechnest die char-werte zu zahlen runter dann hast du nur diese infos:

1. stelle: 4
2. stelle 2
3. stelle 9

aber du kommst damit nicht auf 429.

Und wenn du die chars per Konkatenation zu einem String zusammenfügst kriegst du "429", damit kannst du aber nicht rechnen.

Das einzige was dir bleibt ist die Zahlen mit ihrer Stelligkeit im Zehnersystem zu multiplizieren und die Ergebnisse zu addieren. Genauso würdest du auch binär in dezimal umrechnen:

1010 binär ist dezimal 1*2^3 + 0*2^2 + 1*2^1 + 0*2^0 = 8 + 0 + 2 + 0 = 10
genauso ist
429 nichts anderes als 4*10^2 + 2*10^1 + 9*10^0.

Wenn ich dir jetzt die 429 gebe kennst du aus der eingabe welche wertigkeit welche ziffer hat.
Diese multiplizierst du mit der stelligkeit im zehnersystem (z.b. 4 mit der 10^2) und die summen addierst du, dann hast du die zahl ins zehnersystem konvertiert.

Natürlich bietet die Java-Api auch selbst methoden um Strings in zahlen zu konvertieren, aber es per hand mal selbst zu schreiben hilft zu verstehen was da eigentlich passiert.
Gruß


----------



## Andi_CH (26. Okt 2011)

Aber da du ja die fertige Lösung willst: 


Hier die an dein Problem angepassten Klassen mit Unittest und Hauptprogramm - viel Spass:

Mal sehen was den Lehrer meint, wenn du das so abgibst :lol:


```
public class StringConversion {

	public static boolean checkHexFormat(String in) {
		if (in == null) {
			System.out.println("Eingabe war null"); // Paranoider Programmierstil
			return false;
		}
		if (in.length()!=6) {
			System.out.println("Bitte genau 6 Zeichen eingeben");
			return false;
		}
		in = in.toLowerCase();
		if ((in.charAt(0)!='/') || (in.charAt(1) != 'u')) {
			System.out.println("Die Eingabe muss mit \"/u\" beginnen");
			return false;
		}
		for(int i=2; i<6; i++) {
			char c = in.charAt(i); 
			if (!(((c >= '0') && (c <= '9')) ||
					((c >= 'a') && (c <= 'f'))))
			{
				System.out.println(c + " ist ein ungültiges Zeichen");
				return false;
			}
		}
		return true;
	}

	public static boolean checkDecFormat(String in) {
		if (in == null) {
			System.out.println("Eingabe war null"); // Paranoider Programmierstil
			return false;
		}
		if (in.length()!=6) {
			System.out.println("Bitte genau 6 Zeichen eingeben");
			return false;
		}
		System.out.println("" + in.charAt(0) + " " + in.charAt(1));
		if ((in.charAt(0)!='/') || (in.charAt(1) != 'u')) {
			System.out.println("Die Eingabe muss mit \"/u\" beginnen");
			return false;
		}
		for(int i=2; i<6; i++) {
			char c = in.charAt(i); 
			if (!((c >= '0') && (c <= '9')))
			{
				System.out.println(c + " ist ein ungültiges Zeichen");
				return false;
			}
		}
		return true;
	}

	public static int hexToInt(String s) throws NumberFormatException {
		s = s.toLowerCase();
		int result = 0;
		for(int i=0; i<s.length(); i++) {
			char c = s.charAt(i);
			result *= 16;
			if ((c >= '0') && (c <= '9'))
				result += (s.charAt(i) - '0');
			else if ((c >= 'a') && (c <= 'f'))
				result += (s.charAt(i) - 'a' + 10);
			else
				throw new NumberFormatException("ungültiges Zeichen gefunden");
		}
		return result;
	}

	public static int decToInt(String s) throws NumberFormatException {
		s = s.toLowerCase();
		int result = 0;
		for(int i=0; i<s.length(); i++) {
			char c = s.charAt(i);
			result *= 10;
			if ((c >= '0') && (c <= '9'))
				result += (s.charAt(i) - '0');
			else
				throw new NumberFormatException("ungültiges Zeichen gefunden");
		}
		return result;
	}
}
```


```
import java.io.*;

public class Aufg3a3 {

	protected static String eingabe() {
		BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
		String zeile = null;
		do {
			System.out.print("Geben Sie eine Unicodezahl ein: ");
			try {
				zeile = console.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
		} while(!StringConversion.checkDecFormat(zeile) );
		return zeile;
	}

	public static void main(String[] args) throws Exception {
		String zeile = eingabe();
		int wert = StringConversion.hexToInt(zeile.substring(2));
		char c = (char)wert;
		System.out.println("Der numerische Wert ist " + wert + " Der Buchstabe ist " + c);
	}
}
```


```
import static org.junit.Assert.*;

import org.junit.Test;

public class TestStringConversion {

	@Test
	public void testCheckHexFormat() {
		assertEquals(false, StringConversion.checkHexFormat(null));
		assertEquals(false, StringConversion.checkHexFormat(""));
		assertEquals(false, StringConversion.checkHexFormat("/abcde"));
		assertEquals(false, StringConversion.checkHexFormat("/ubzde"));
		assertEquals(true, StringConversion.checkHexFormat("/u09af"));
		assertEquals(true, StringConversion.checkHexFormat("/u09AF"));
	}

	@Test
	public void testCheckDecFormat() {
		assertEquals(false, StringConversion.checkDecFormat(null));
		assertEquals(false, StringConversion.checkDecFormat(""));
		assertEquals(false, StringConversion.checkDecFormat("/abcde"));
		assertEquals(false, StringConversion.checkDecFormat("/u12a3"));
		assertEquals(true, StringConversion.checkDecFormat("/u1234"));
	}

	@Test
	public void testHexToInt() {
		try {
			assertEquals(0, StringConversion.hexToInt("0"));
			assertEquals(9, StringConversion.hexToInt("9"));
			assertEquals(10, StringConversion.hexToInt("A"));
			assertEquals(15, StringConversion.hexToInt("f"));
			assertEquals(16, StringConversion.hexToInt("10"));
			assertEquals(255, StringConversion.hexToInt("Ff"));
		} catch (Exception e) {
			fail("unerwartete Exception");
		}
		try {
			StringConversion.hexToInt("g");
			fail("Keine Exception");
		} catch (NumberFormatException e) {
			assertTrue(true);
		}
	}

	@Test
	public void testDecToInt() {
		try {
			assertEquals(0, StringConversion.decToInt("0"));
			assertEquals(9, StringConversion.decToInt("9"));
			assertEquals(10, StringConversion.decToInt("10"));
			assertEquals(99, StringConversion.decToInt("99"));
		} catch (Exception e) {
			fail("unerwartete Exception");
		}
		try {
			StringConversion.decToInt("g");
			fail("Keine Exception");
		} catch (NumberFormatException e) {
			assertTrue(true);
		}
	}
}
```


----------



## puschelemo21 (26. Okt 2011)

äh ja 
ich darf sowas nich nehmen.
ich darf nur if verwenden keine zusätzlichen Statements die wir noch nicht gemacht haben genau das is das Problem.

Spinnst wohl das geb ich nich so ab


----------



## Andi_CH (26. Okt 2011)

Firephoenix hat gesagt.:


> Natürlich bietet die Java-Api auch selbst methoden um Strings in zahlen zu konvertieren, aber es per hand mal selbst zu schreiben hilft zu verstehen was da eigentlich passiert.
> Gruß


parseInt wäre doch VIEL zu einfach (unser Informatiker Azubi hatte eine beinahe passende Conversionklasse auf Lager ;-) die haben das mal implementiert um die Zahlensysteme zu verstehen)


----------



## Andi_CH (26. Okt 2011)

puschelemo21 hat gesagt.:


> äh ja
> ich darf sowas nich nehmen.
> ich darf nur if verwenden keine zusätzlichen Statements die wir noch nicht gemacht haben genau das is das Problem.
> 
> Spinnst wohl das geb ich nich so ab



Aber es steht alles drin was du brauchst - vor allem die Sache mit dem "Ziffern nebeneinander schreiben"

Nur if ohne Loop??? na ja - im Prinzip geht das auch


```
resultat = s.charAt(2)-'0' * 1000 + s.charAt(3)-'0' * 100 + s.charAt(4)-'0' * 10 + s.charAt(5)-'0';
```

Aber das ist ja Horror


----------



## puschelemo21 (26. Okt 2011)

ja das Problem an diesen Vorlesungen is die Aufgaben Orientieren sich 8 Seiten weiter im Script.
aber was bringts mir 8 Seiten weiter zu lesen wenn das Script so Stichpunktartig aufgeschrieben is....
ich kann ja mal die Kompletten Aufgaben posten....



Praktikum Programmieren 1 im Studiengang Informatik
Aufgabe 3 (Boolsche Ausdrücke, Scannen von Eingaben)

    Was macht folgendes Programm? (Erklären Sie die einzelnen Zeilen und beschreiben Sie das Gesamtergebnis!)


```
public class Aufg3a {
       public static void main(String[] args) {
          boolean op1 = false;
          boolean op2 = false;
     
          System.out.println(" &&   | " + op2 + " | " + !op2);
          System.out.println("------|-------|------");
          System.out.println(op1 + " | " + (op1 && op2) + " | " + (op1 && !op2));
          op1 = !op1;
          System.out.println(op1 + "  | " + (op1 && op2) + " | " + (op1 && !op2));
       }
    }
```
    Ergänzen Sie das Programm jeweils um ein analoges "Code-Stück" für die Operatoren || , | , & , ^ .
    Schreiben Sie nun ein kleines Programm, das einen dyadischen logischen Ausdruck mit einem der unter Teilaufg. a genannten Operatoren einliest, das Ergebnis berechnet und ausgibt. Die logischen Ausdrücke sollen textuell in einer verkürzten Form eingegeben werden können, illustriert durch nachfolgende Beispiele:
    T&F oder T|T oder F^T ...
    D. h. statt true wird der Buchstabe T, statt false der Buchstabe F in der Eingabe verwendet. (Leerzeichen zwischen Operanden und Operatoren sind aus Einfachheitsgründen verboten.)
    Verwenden Sie zum zeichenweisen Einlesen System.in.read() (zur Verwendung siehe InputToUppercase in der Vorl.).
    Falls fälschlicherweise eine verkehrte Buchstabenfolge eingegeben wird, soll eine Fehlermeldung ausgegeben und das Programm vorzeitig beendet werden.
    Das Programm braucht während eines Laufes nur einen Ausdruck zu berechnen. Es sind also keine Schleifen, auch nicht für wiederholte Eingabe, erforderlich.
    Es sind zumindest die Operatoren, die aus einem Zeichen bestehen, zu berücksichtigen (| , & , ^ ). Wer sich damit langweilt, sollte auch die Operatoren bestehend aus zwei Zeichen akzeptieren (&&, || ).
    Wir wenden uns noch einmal der Unicode-Ersatzdarstellung zu.
    In Aufgabe 2 haben wir die Umwandlung der Ersatzdarstellung in das zugehörige Unicodezeichen dem ? (wem denn?) überlassen. Das wollen wir nun selbst in die Hand nehmen, indem die Ersatzdarstellung für ein Unicode-Zeichen von der Standardeingabe (Konsole) eingelesen und verarbeitet wird.
        Schreiben Sie zunächst ein Programm, das Zeichen für Zeichen von der Standardeingabe liest und prüft, ob die Eingabe von der Form \uxxxx ist, wobei x jeweils eine der bekannten Hex-Ziffern  (0..9,a..f) sein soll (Großbuchstaben brauchen nicht unbedingt berücksichtigt werden).

        Falls diese Syntax bei der Eingabe nicht eingehalten wird, soll eine qualifizierte Fehlermeldung ausgegeben und das Programm beendet werden.
        Als falsche Eingabe gilt auch, wenn diese zu kurz oder zu lang ist.
        Erweitern Sie das Programm nun so, dass die eingegebene Ersatzdarstellung in den zugehörigen Zahlwert (int) des Unicode-Zeichens umgewandelt wird. Dazu definieren Sie sich verschiedene Variablen für die Stellen der Hex-Ziffern, rechnen diese ins Dezimalsystem um und fügen sie zu einem Zahlwert zusammen.

        Geben Sie diesen Zahlwert und das Unicode-Zeichen selbst auf die Standardausgabe (Konsole) aus.

        Beispiel: Bei Eingabe von \u0041 soll folgende Zeile ausgegeben werden:
        hex: 0041, dez: 65, char: A .

    Auch bei dieser Aufgabe soll (noch) auf Schleifen verzichtet werden, wenn nötig unter Inkaufnahme von Code-Duplikation. Außer System.in.read() und System.out.println()sollen keine Bibliotheksfunktionen verwendet werden. 

die erste Aufgabe is fertig die zweite fehlt nur noch das ich überprüfe zwischen a und A 
un diel dritte is eben das was ich gepostet hab aber kp ich komm einfach nich weiter vll geb ich die Arbeit einfach so ab. Wenn unser Tutor nicht richtig helfen kann oder will


----------



## Firephoenix (26. Okt 2011)

Das erinnert mich an diese beliebte Palindromfrage und an 
boolean isPalindrom = new StringBuilder(s).reverse().toString().equals( s ); 

@puschelemo21
schau dir nochmal die letzten beiträge mit den rechenmethoden an und mach dir mal gedanken wie das in java aussehen könnte (hex funktioniert genauso).
dazu brauchst du nichts anderes als if,+,mal,geteilt und evtl modulo.
Gruß


----------



## Andi_CH (26. Okt 2011)

@puschelemo21 - Bitte verwende JAVA -tags - wie es oben schö rot steht - es ist viel einfacher zu lesen.

Schau dir meinen Monstercode ruhig an - in der Klasse StringConversion sind deine Probleme gelöst.
Was dort mit for gemacht ist, kannst du immer in einzelenen Zeilen codieren

For heisst nur: Mache x mal dasselbe ;-)


----------



## puschelemo21 (26. Okt 2011)

Kennt jemand von euch n gutes Buch oder sowas? Weil dann lass ich die Vorlesungen saußen un mach das auf meine Art.


----------



## Firephoenix (26. Okt 2011)

Tutorial / Java Grundlagen
Java Video Kurs - Java Video Tutorials - Online Java lernen!
Galileo Computing :: Java ist auch eine Insel –
Programmierkurs Java

Syntax lernen ist aber nur ein kleiner Teil vom Programmieren, man muss die Werkzeuge die man hat auch verstehen und anwenden können - und das geht nur mit Übung und Fehlern 
Gruß


----------



## puschelemo21 (26. Okt 2011)

Danke. Mir ist das schon klar das Fehler passieren können. ich hab  nun char auf int geändert und versuchs nun so. Ich hab ne Zeit lang php programmiert aber ich merk schon Java isn ganzes Stück anders. Ich finds nur schade das unser Tutorium garnix bringt genauso wie die Vorlesungen ... :/

hab jetzt als "Beispiel" versucht:

      int ergebnis  ;
      ergebnis= zeichen3 *10;
      System.out.println(ergebnis);
ausgeführt aber das ergibt ja 570


----------



## thisnamesoundsfemale (6. Nov 2016)

Hallo ihr Java sprechenden,
es ist zwar schon ein Weilchen her, aber ich muss aktuell die gleiche Aufgabe lösen und habe aber einen ganz anderen Code geschrieben...



```
public class Jana2 {
public static void main(String[] args) throws Exception {

  System.out.println("Hi! Gib bitte den umzuwandelnden Unicode ein.");

  int symbol1 = System.in.read();
  if (symbol1 != 92) System.out.println("Ups, Falsches Eingabeformat... \nAn erster Stelle muss ein '\\' sein.");
  else {

   int symbol2 = System.in.read();
   if (symbol2 != 'u') System.out.println("Ups, Falsches Eingabeformat... \nAn zweiter Stelle muss ein 'u' sein.");
   else {

    int symbol3 = System.in.read();
    char buchstabe3 = (char) symbol3;
    if (!(symbol3 >= '0' && symbol3 <= '9') && (!(symbol3 >= 'a' && symbol3 <= 'f'))) System.out.println("Ups, Falsches Eingabeformat... \nBitte verwende für die 3. Stelle nur Hexziffern (0 - f).");
    else {

     int symbol4 = System.in.read();
     char buchstabe4 = (char) symbol4;
     if (!(symbol4 >= '0' && symbol4 <= '9') && (!(symbol4 >= 'a' && symbol4 <= 'f'))) System.out.println("Ups, Falsches Eingabeformat... \nBitte verwende für die 4. Stelle nur Hexziffern (0 - f).");
     else {

      int symbol5 = System.in.read();
      char buchstabe5 = (char) symbol5;
      if (!(symbol5 >= '0' && symbol5 <= '9') && (!(symbol5 >= 'a' && symbol5 <= 'f'))) System.out.println("Ups, Falsches Eingabeformat... \nBitte verwende für die 5. Stelle nur Hexziffern (0 - f).");
      else {

       int symbol6 = System.in.read();
       char buchstabe6 = (char) symbol6;
       if (!(symbol6 >= '0' && symbol6 <= '9') && (!(symbol6 >= 'a' && symbol6 <= 'f'))) System.out.println("Ups, Falsches Eingabeformat... \nBitte verwende für die 6. Stelle nur Hexziffern (0 - f).");
       else {

        int symbol7 = System.in.read();
        if (symbol7 != 13) System.out.println("Ups, Falsches Eingabeformat... \nMehr als 6 Zeichen sind nicht erlaubt.");
        else {

         /// Probleme ab hier

         System.out.println();
         System.out.println("Vielen Dank.");
         System.out.println("Folgendes ist das Ergebnis deiner Eingabe:");
         int test = ((1000 * (symbol3 - 48) + 16) + (100 * (symbol4 - 48) + 16) + (10 * (symbol5 - 48) + 16) + (symbol6 - 48)); //kompletter unsinn ?? funktioniert auch nicht....
         char test1 = (char) test;
         System.out.println();
         System.out.println("dez: " + test + ", char: " + test1);


         //dies dient zu test zwecken was wann wo wie gespeichert ist
         System.out.println("symbol3: " + symbol3 + ", buchstabe3: " + buchstabe3 + " wert3: ");
         System.out.println("symbol4: " + symbol4 + ", buchstabe4: " + buchstabe4 + " wert4: ");
         System.out.println("symbol5: " + symbol5 + ", buchstabe5: " + buchstabe5 + " wert5: ");
         System.out.println("symbol6: " + symbol6 + ", buchstabe6: " + buchstabe6 + " wert6: ");
        }
       }
      }
     }
    }
   }
  }
}
}
```



Ich hänge vorallem an der Stelle wo ich die eingabe in dezimal und als char ausgeben soll.
Erst wollte ich es mit boolean probieren der unterscheidet zwischen zb


```
boolean op1 = (symbol3>='0' && symbol3<='9');
boolean op2 = (symbol3>='a' && symbol3<='f');
if opt1 = 1000*(symbol3-48);
if opt2 = 1000*(symbol3-87);
         
char buchstabe3 = (char) symbol3;
if (!opt1 && !opt2)System.out.println("Ups, Falsches Eingabeformat... \nBitte verwende für die 3. Stelle nur Hexziffern (0 - f).");
```

um dann entsprechende Umrechnungen ins Dezimalsystem zu erleichtern. Aber so funktioniert das nicht habe ich schon rausgefunden. Bitte seid gnädig mit mir ich lerne erst seit ca 2 Wochen Java und bin dafür auch ganz stolz auf meinen Code, aber er macht halt einfach nicht was er soll.
Auch die Forenbeiträge weiter oben haben mich leider nicht wirklich zu DEM problemlösenden Gedanke angestoßen..

Ich will aufjedenfall nochmal unterscheiden zwischen den Fällen:
1. eine Variable ist eine Ziffer (0 - 9)
2. eine Variable ist ein Buchstabe (a - f)
danach will ich die Entsprechenden Variablen so "bewerten" das ich sie am Ende zu einer Dezimalzahl zusammensetzen kann.

Außer System.in.read() und System.out.println() sollen keine Bibliotheksfunktionen verwendet werden. Aber boolean, if und co schon.


Ich hoffe doch sehr dass diesen Beitrag in diesem alten Thread überhaupt jemand liest und dieser jemand mir das Brett vor meinem Kopf entfernen kann, bzw mir die notwendigen Werkzeuge dazu ausleiht.

Bei interesse kann ich noch andere Codes von meinen vorherigen Versuchen posten aber der oben ist, denke ich, der sauberste und schlankeste.

Vielen Dank schonmal für eure Bemühungen!


----------

