Aktuelle Zeit: 24. Jan 2017, 08:02

  Neue Beiträge

Ereignisse!!!
von: vovan1 8. Dez 2016, 23:03 zum letzten Beitrag 8. Dez 2016, 23:03

Was habt ihr gelesen?
von: Alex C 10. Okt 2016, 14:42 zum letzten Beitrag 10. Okt 2016, 14:42

Lesenswertes
von: Alex C 10. Mär 2015, 20:49 zum letzten Beitrag 10. Mär 2015, 20:49

  Suche



Erweiterte Suche

  Kategorien

Kategorie
alle Themen allgemein erstmal hierhin

Kategorie

Kategorie


Neues Thema erstellenAntwort erstellen Seite 3 von 3   [ 23 Beiträge ]
Gehe zu Seite  Vorherige  1, 2, 3
AutorNachricht
 Betreff des Beitrags: Re: Übungen Programmirung (Lösungen/Fragen)
BeitragVerfasst: 25. Apr 2011, 23:51 
Vielschreiber
Vielschreiber||
Benutzeravatar

Registriert: 02.2009
Beiträge: 922
Geschlecht: männlich
Highscores: 38
Aufgabe H6

public class Binaerbaumvergleich
{



// Idee: Gegeben seien BaumA und BaumB, bei denen man prьfen mцchte ob sie die gleichen Elemente enthalten.
// Durch ein Array merken wir uns, welche Elemente der Baum A enthдlt. Hierfьr erstellen wir ein boolean Array, wo zu Beginn jedes Feld den Wert "False" hat.
// Jeden Knoten i aus BaumA merken wir uns, indem wir die i-te Stelle des Arrays auf True setzen.

public static boolean (Searchtree<K,D> BaumA, Searchtree<K,D> BaumB)
{

Boolean[] InhaltA = New boolean[100]; //Eigentlich mьsste man ein sich automatisch vergrцЯerndes Array erstellen. Jedes Arraystelle wird autoamtisch mit "False" erstellt!

WelcheElemente (BaumA.root, InhaltA); // Der Aufruf dieser Methode markiert all die Stellen im Array "InhaltA" mit "True" dessen Indexstelle als Knoten im "BaumA" vorkommen.

return (Vergleiche (BaumB.root, InhaltA)); // Diese Funktion gibt "True" zurьck, wenn alle Knoten im "BaumB" im Array "InhaltA" durch "True" markiert sind.
// Da BaumA und BaumB, nach Aufgabenstellung, immer gleichviele Elemente besitzen, kцnnen wir sichergehen,
// dass wenn an dieser Stelle des Codes alle Knoten des Baumes "BaumB" im Array "Inhalt" A durch "True" markiert sind,
// BaumA und BaumB die selben Elemente enthalten mьssen.
}




private static void WelcheElemente (Searchtreenode<K,D> Knoten, boolean[] Inhalt) // Setzt mit Hilfe von Rekursion fьr jeden Knoten im "BaumB"
// die passende Arraystelle im Array "Inhalt" auf "True".
{

Inhalt[Knoten.key] = True; // Markiert die zum ьbergebenen Knoten gehцrige Arraystelle mit "True"

if (Knoten.left != Null) // Wenn der der Methode ьbergebene Knoten ein linkes Kind hat ...
{ WelcheElemente (Knoten.left); } // wird die Methode "WelcheElemente" auch fьr dieses Kind aufgerufen

if (Knoten.right != Null) // Wenn der der Methode ьbergebene Knoten ein rechtes Kind hat .. .
{ WelcheElemente (Knoten.right); } // wird die Methode "WelcheElemente" auch fьr dieses Kind aufgerufen

}



private static boolean Vergleiche (Searchtreenode<K,D> Knoten, boolean[] Array) // Prьft mit Hilfe von Rekursion ob es fьr jedem im "BaumB" vorkommenden Knoten
// eine passende Markierung im ьbergebnen Array gibt.
{
if ( !(Array[Knoten.key]) ) // Wenn der der Methode ьbergebene Knoten im Array nicht vermerkt ist ...
{ return false; } // geben alle Rekursionsaufrufe "False" zurьck.


if ( !(Vergleiche (Knoten.left, Array)) ) // Wenn ein Knoten des Teilbaumes links vom derzeitigen Knoten nicht im Array markiert ist ...
{ return false; } // geben alle Rekursionsaufrufe "False" zurьck

if ( !(Verleiche (Knoten.right, Array)) ) // Wenn ein Knoten des Teilbaumes rechts vom derzeitigen Knoten nicht im Array markiert ist ...
{ return false; } // geben alle Rekursionsaufrufe "False" zurьck


return true; // Wenn der jetzige Knoten, sowie beide Kinderknoten, im Array vermerkt waren, wird "True" zurьckgegeben.

}

_________________
TODO List:
Analyze existence... Annihilate possible Contradictions... Create unbearable Fear...


Nach oben
 Profil  
 
 Betreff des Beitrags: Re: Übungen Programmirung (Lösungen/Fragen)
BeitragVerfasst: 28. Jun 2011, 09:58 
Vielschreiber
Vielschreiber||
Benutzeravatar

Registriert: 02.2009
Beiträge: 922
Geschlecht: männlich
Highscores: 38
Code:
import java.util.Iterator;
import java.util.LinkedList;

public class Uebung10 {

   public static void main(String[] args) {
      
       if(args.length != 0){
           String temp = args[0];
           byte[][] matrix = {{(byte)temp.charAt(0) , (byte)temp.charAt(1) , (byte)temp.charAt(2) , (byte)temp.charAt(3) },
                         { (byte)temp.charAt(4) , (byte)temp.charAt(5) , (byte)temp.charAt(6) , (byte)temp.charAt(7) },
                         { (byte)temp.charAt(8) , (byte)temp.charAt(9) , (byte)temp.charAt(10) , (byte)temp.charAt(11) },
                         { (byte)temp.charAt(12) , (byte)temp.charAt(13) , (byte)temp.charAt(14) , (byte)temp.charAt(15) }};
      
      Element root=new Element(matrix);
      root.solve();
          }else{
            byte[][] matrix = { { '1', '2', '3', '4' },
                         { '5', '6', '7', '8' },
                         { 'D', '9', 'B', 'C' },
                         { 'A', 'E', '*', 'F' } };
                         
      Element root=new Element(matrix);
      root.solve();
      }
   }
}

class Element{
   public static final byte[][] aim = { { '1', '2', '3', '4' }, { '5', '6', '7', '8' },
      { '9', 'A', 'B', 'C' }, { 'D', 'E', 'F', '*' } };
   private final byte[][] matrix;
   private static boolean finish;
   private static long numOfElements=0;
   private Element parent=null;
   private static Element root;
   private LinkedList<Element> child=new LinkedList<Element>();
   private static LinkedList<Element> toDo=new LinkedList<Element>();
   private byte x,y,direction;
   
   private boolean[] whereCanIGo={true,true,true,true};
   
   public Element(byte[][] matrix){
      root=this;
      numOfElements++;
      direction=-1;
      this.matrix=matrix;
      setXY();
   }
   
   private Element(byte[][] matrix,byte direction,byte x,byte y,Element parent){
      this.matrix=matrix;
      this.parent=parent;
      this.direction=direction;
      if(direction==0) this.matrix[y--][x]=matrix[y][x];
      else if(direction==1) this.matrix[y++][x]=matrix[y][x];
      else if(direction==2) this.matrix[y][x--]=matrix[y][x];
      else if(direction==3) this.matrix[y][x++]=matrix[y][x];
      this.y=y;
      this.x=x;
      this.matrix[y][x]='*';
   }
   
   private void setXY(){
      for (byte i = 0; i < matrix.length; i++) {
         for (byte j = 0; j < matrix[i].length; j++) {
            if(matrix[i][j]=='*') {
               x=j;
               y=i;
               return;
            }
         }
      }
   }
   
   private byte[][] getClone(){
      byte[][] nm=new byte[matrix.length][matrix[0].length];
      for (byte i = 0; i < matrix.length; i++) {
         for (byte j = 0; j < matrix[i].length; j++) {
            nm[i][j]=matrix[i][j];
         }
      }
      return nm;
   }
   
   public void solve(){
      solve(false);
      long start=System.currentTimeMillis();
      while(toDo.size()>0){
         Element element=toDo.removeFirst();
         if(!Element.finish) element.solve(false);
         else break;
      }
      long end=System.currentTimeMillis();
      System.out.println(numOfElements+" Elemente in "+(end-start)+" Millisekunden");
   }
   
   private void solve(boolean b) {
      if(Element.finish) return;
      else{
        setToGo();
        for (byte i = 0; i < whereCanIGo.length; i++) {
         if(whereCanIGo[i]) {
            Element e=new Element(getClone(),i,x,y,this);
            if(!root.contains(e)){
               if(Element.finish) return;
               numOfElements++;
               child.add(e);
               toDo.addLast(e);
                Element.finish=e.isFinish();
            }
         }
        }
      }
      
   }
   
   private boolean contains(Element e) {
         
      boolean contians=true;
       main: for (int i = 0; i < matrix.length; i++) {
             for (int j = 0; j < matrix[i].length; j++) {
              if(e.matrix[i][j]!=matrix[i][j]){
                 contians=false;
                 break main;
              }
            }
        }
      if(contians) return true;
      else{
         for (Iterator<Element> iterator = child.iterator(); iterator.hasNext();) {
            Element next = iterator.next();
            if(next.contains(e)) return true;
         }
         return false;
      }      
   }

   private void setToGo(){
      if(x==0)whereCanIGo[2]=false;
      else if(x==3) whereCanIGo[3]=false;
      
      if(y==0)whereCanIGo[0]=false;
      else if(y==3) whereCanIGo[1]=false;
   }
   
   private boolean isFinish(){
      for (int i = 0; i < matrix.length; i++) {
         for (int j = 0; j < matrix[i].length; j++) {
            if(matrix[i][j]!=aim[i][j]) return false;
         }
      }
      printRoad();
      System.out.println("Fertig...");
      return true;
   }

   private void printRoad() {
      String re="";
      Element e=this;
      while(e!=null){
         if(e.direction==0) re="oben\n"+re;
         else if(e.direction==1) re="unten\n"+re;
         else if(e.direction==2) re="rechts\n"+re;
         else if(e.direction==3) re="links\n"+re;
         e=e.parent;
      }
      System.out.println(re);
   }
}

_________________
TODO List:
Analyze existence... Annihilate possible Contradictions... Create unbearable Fear...


Nach oben
 Profil  
 
 Betreff des Beitrags: Re: Übungen Programmirung (Lösungen/Fragen)
BeitragVerfasst: 10. Nov 2011, 16:39 
Vielschreiber
Vielschreiber||
Benutzeravatar

Registriert: 02.2009
Beiträge: 922
Geschlecht: männlich
Highscores: 38
Otprav tutoru svoemu :thumbup: !!!!

Code:

public class Reversi {
    /*
     * Gibt zurueck, wieviele Steine des Spielers "spieler" auf dem Spielbrett
     * "spielbrett" liegen.
     */
    public static int zaehleSteine(int[][] spielbrett, int spieler) {
        int anzahl = 0;
        for( int y = 0; y< spielbrett.length;y++){
            for( int x = 0; x< spielbrett.length;x++){
                if(spielbrett[x][y] == spieler){
                    anzahl++;
                }
            }
        }
        return anzahl;
    }

    /*
     * Gibt zurueck, ob Spieler "spieler" auf dem Spielbrett "spielbrett" einen
     * Zug taetigen kann.
     */
    public static boolean zuegeMoeglich(int[][] spielbrett, int spieler) {
        boolean zuegeMoeglich = false;
        for( int y = 0; y< spielbrett.length;y++){
            for( int x = 0; x< spielbrett.length;x++){
                if(felderZuSetzen(spielbrett,y,x,spieler).length > 0){
                    zuegeMoeglich = true;
                }
            }
        }// Aufgabe d)
        return zuegeMoeglich;
    }

    /*
     * Fuehrt einen Zug von "spieler" auf dem Spielbrett "spielbrett" aus,
     * wenn dies moeglich ist.
     */
    public static void macheZug(int[][] spielbrett, int spieler) {
        if (!zuegeMoeglich(spielbrett, spieler)) {
            System.out.println("Spieler " + spieler + " kann keinen Zug taetigen!");
        } else {
            int[][] felderZuSetzen = {};
            while(felderZuSetzen.length == 0){
                System.out.print("Spieler " + spieler + " geben Sie bitte eine Zeile ein: ");
                int z = Integer.parseInt(System.console().readLine());
                System.out.print("Spieler " + spieler + " geben Sie bitte eine Spalte ein: ");
                int s = Integer.parseInt(System.console().readLine());
                felderZuSetzen = felderZuSetzen(spielbrett,z-1,s-1,spieler);   
               
                if(felderZuSetzen.length == 0)System.out.println("Diese Zug war leider illegal!");
            }

            for( int y = 0; y< felderZuSetzen.length;y++){
                spielbrett [(felderZuSetzen[y][0])] [(felderZuSetzen[y][1])] = spieler;
            }// Aufgabe c)
        }
    }

    /*
     * Kontrolliert das Spiel und setzt die verschiedenen Funktionen zusammen.
     */
    public static void main(String[] args) {

        int[][] spielbrett = new int [8][8]; // Aufgabe a)

        spielbrett [3] [3] = 1;
        spielbrett [4] [4] = 1;
        spielbrett [3] [4] = 2;
        spielbrett [4] [3] = 2;

        int aktuellerSpieler = 1;
        while (   Reversi.zuegeMoeglich(spielbrett, 1)
        || Reversi.zuegeMoeglich(spielbrett, 2)) {
            Reversi.ausgabe(spielbrett);
            Reversi.macheZug(spielbrett, aktuellerSpieler);
            aktuellerSpieler = andererSpieler(aktuellerSpieler);
        }
        int steineSpieler1 = zaehleSteine(spielbrett, 1);
        int steineSpieler2 = zaehleSteine(spielbrett, 2);
        if (steineSpieler1 > steineSpieler2) {
            System.out.println("Spieler 1 hat "
                + steineSpieler1 + ":" + steineSpieler2 + " gewonnen!");
        } else if (steineSpieler2 > steineSpieler1) {
            System.out.println("Spieler 2 hat "
                + steineSpieler2 + ":" + steineSpieler1 + " gewonnen!");
        } else {
            System.out.println("Unentschieden!");
        }
    }

    public static int andererSpieler(int spieler) {
        if (spieler == 1) {
            return 2;
        }
        return 1;
    }

    /*
     * Gibt das Spielbrett aus.
     */
    public static void ausgabe(int[][] spielbrett) {
        //Spaltennummer (+1 da wir im Array 0-basiert zaehlen):
        System.out.print("  ");
        for (int spIdx = 0; spIdx < spielbrett[0].length; spIdx++) {
            System.out.print("| " + (spIdx + 1) + " ");
        }
        System.out.println("|");
        System.out.println("--" + repeat("+---", spielbrett.length + 1));

        for (int zeilIdx = 0; zeilIdx < spielbrett.length; zeilIdx++) {
            int[] zeile = spielbrett[zeilIdx];
            //Zeilennummer (+1 da wir im Array 0-basiert zaehlen):
            System.out.print((zeilIdx + 1) + " ");
            for (int feld : zeile) {
                System.out.print("| " + steinFuerSpieler(feld) + " ");
            }
            System.out.println("| " + (zeilIdx + 1));
            System.out.println("--" + repeat("+---", spielbrett.length + 1));
        }

        //Spaltennummer (+1 da wir im Array 0-basiert zaehlen):
        System.out.print("  ");
        for (int spIdx = 0; spIdx < spielbrett[0].length; spIdx++) {
            System.out.print("| " + (spIdx + 1) + " ");
        }
        System.out.println("|");
    }

    /*
     * Wiederholt einen String "str" "anzahl" mal.
     */
    public static String repeat(String str, int anzahl) {
        String r = "";
        for (int i = 0; i < anzahl; i++)
            r += str;

        return r;
    }

    /*
     * Bestimmt, wie ein Feld mit Wert "spieler" dargestellt wird.
     */
    public static char steinFuerSpieler(int spieler) {
        switch (spieler) {
            case 1:  return '#';
            case 2:  return 'O';
            default: return ' ';
        }
    }

    public static int[][] felderZuSetzen(int[][] spielbrett, int zeilIdx,
    int spIdx, int spieler) {
        /*
         * Regeln:
         *  (1) Das Feld, auf das gesetzt wird, muss frei sein
         *  (2) Vom gesetzten Feld ausgehend muss eine Reihe (vertikal, horizontal
         *      oder diagonal) von Steinen des Gegners belegt werden, an die sich
         *      ein eigener Stein anschliesst. Diese Steine werden umgedreht.
         */
        int[][] res = {};
        if (!aufSpielbrett(zeilIdx, spIdx) || spielbrett[zeilIdx][spIdx] != 0) {
            return res;
        }

        int[][] richtungen = { { 1, -1}, { 1, 0}, { 1, 1},
                { 0, -1},          { 0, 1},
                {-1, -1}, {-1, 0}, {-1, 1}};
        //Checke in jede Richtung:
        for (int[] richtung : richtungen) {
            int zeilenDiff = richtung[0];
            int spDiff = richtung[1];

            //Finde die Folge aller Steine des Gegners in dieser Richtung:
            int curZeil = zeilIdx;
            int curSp = spIdx;
            int[][] anderePos = {};
            while (true) {
                curZeil = curZeil + zeilenDiff;
                curSp = curSp + spDiff;
                int andererSpieler = Reversi.andererSpieler(spieler);
                if (!aufSpielbrett(curZeil, curSp)) {
                    break;
                } else if (spielbrett[curZeil][curSp] == andererSpieler) {
                    anderePos = erweiterePosArray(anderePos, curZeil, curSp);
                } else {
                    break;
                }
            }

            //Ueberpruefe, ob dies ein korrekter Zug war:
            if (   aufSpielbrett(curZeil, curSp)
            && spielbrett[curZeil][curSp] == spieler
            && anderePos.length > 0) {
                //Fuege die Positionen dem Ergebnis hinzu:
                for (int[] pos : anderePos) {
                    res = erweiterePosArray(res, pos[0], pos[1]);
                }
            }
        }

        //Wenn andere Steine umgelegt werden durften, war der Zug korrekt:
        if (res.length > 0) {
            res = erweiterePosArray(res, zeilIdx, spIdx);
        }

        return res;
    }

    public static boolean aufSpielbrett(int curZeil, int curSp) {
        return (0 <= curZeil && curZeil < 8 && 0 <= curSp && curSp < 8);
    }

    public static int[][] erweiterePosArray(int[][] posArray,
    int neueZeile, int neueSpalte) {
        int[][] res = new int[posArray.length + 1][];
        for (int i = 0; i < posArray.length; i++) {
            res[i] = posArray[i];
        }
        int[] neuePos = { neueZeile, neueSpalte };
        res[posArray.length] = neuePos;
        return res;
    }
}

_________________
TODO List:
Analyze existence... Annihilate possible Contradictions... Create unbearable Fear...


Nach oben
 Profil  
 
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Neues Thema erstellenAntwort erstellen Seite 3 von 3  [ 23 Beiträge ]
Gehe zu Seite  Vorherige  1, 2, 3


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
cron


© phpBB® Forum Software » Style by Daniel St. Jules Gamexe.net | phpBB3 Forum von phpBB8.de