Programmideen für Anfänger

mikey

Ich meinte ja Tic Tac Toe mit KI. Ohne ist ja wirklich einfach Kleines Beispiel, allerdings nicht von mir:

#include <iostream>
#include <conio>
#include "ic.hpp"

//namespace für std cout & co
using namespace std;
//namespace für improved console
using namespace ic;
//namespace für improved console shorties (clrscr, gotoxy ...)
using namespace ic::shorties;

//Konstanten für Pfeiltasten
const short UP = 72;
const short DOWN =  80;
const short LEFT = 75;
const short RIGHT = 77;

//Funktion zum 'zeichnen' des leeren Spielfelds und initialisieren
//des char feldes (Übergabeparameter Zeiger auf char Array)
void spielfeld(char *arr)
{
   //Bildschirm löschen
   clrscr();
   //Cursor an oberste linke Position
   gotoxy(0,0);
   //Spielfeld 'malen'
   cout << "  A   B   C"<<endl;
   for(short y=1;y<4;y++)
   {
      cout <<y<<"   |   |"<<endl;
      cout <<"  -   -   -"<<endl;
   }
   //char Array löschen (3*3=9)
   for(short y=0;y<9;y++) arr[y]=' ';
}

//Funktion zum überprüfen ob ein Stein an einer bestimmten Position (x,y) gesetzt ist
//bzw ob alle Positionen schon gesetzt sind (bool all)
//Übergabeparameter Zeiger auf char Array, Positionen short x,y und
//ob das ganze Feld überprüft werden soll (bool all)
//Rückgabewert bool=true wenn Feld/er besetzt
//bool=false wenn Feld/er leer
bool gestoned(char *arr,short x,short y,const bool all)
{
   //Wenn alle Felder überprüft werden sollen
   if(all)
   {
      //dann Hilfszählvariable c mit 0 init.
      short c=0;
      //Alle 9 Felder durchlaufen und wenn Inhalt nicht leer
      //dann Zählvariable c um 1 incrementieren
      for(y=0;y<9;y++) if(arr[y]!=' ') c++;
      //Rückgabe Zählvariable = 9
      //Wenn alle Felder gesetzt also true zurück sonst false
      return c==9;
   }
   //Rückgabe Feld ungleich Leerzeichen (Feld besetzt=true sonst false)
   return arr[y+x*3]!=' ';
}

//Funktion zum cruisen durchs Spielfeld und zum Steine ablegen
//Übergabeparameter Zeiger auf char Array und Spielstein
void set_stone(char *arr,const char zeichen)
{
   //Startpostion des Cursors auf dem Bildschirm (x Achse=2, y Achse=1)
   int x=2,y=1;
   //char position (zum merken des Tastencodes
   char position=NULL;
   //solange durchlaufen wie eingabe ungleich 'Enter' (13) oder die Position schon durch
   //nen anderen Stein besetzt ist
   while (position != 13 || gestoned(arr,(x-2)/4,(y-1)/2,false))
   {
      //Mit Cursor an Startposition springen
      gotoxy(x,y);
      //Tastatureingabe in position merken
      position = getch ();
      switch (position)
      {
         case DOWN:
         //Wenn runter gedrückt und Cursor dann nicht ausserhalb Spielfeld dann y Achse +2
         if(y+2<6) y+=2;
      break;
         case LEFT:
         //Wenn links gedrückt und Cursor dann nicht ausserhalb Spielfeld dann x Achse -4
         if(x-4>1) x-=4;
      break;
         case RIGHT:
         //Wenn rechts gedrückt und Cursor dann nicht ausserhalb Spielfeld dann x Achse +4
         if(x+4<11) x+=4;
      break;
         case UP:
         //Wenn hoch gedrückt und Cursor dann nicht ausserhalb Spielfeld dann y Achse -2
         if(y-2>0) y-=2;
      break;
    }
    //Zur neuen Position springen
    gotoxy(x,y);
    //Bischen Schlafen um ein bischen Trägheit zu simulieren
    Sleep (80);
  }
  //Zeichen 'malen'
  cout << zeichen;
  //Position vom Bildschirm auf Position im Array runterrechnen
  x=(x-2)/4;
  y=(y-1)/2;
  //Zeichen setzen
  arr[y+x*3]=zeichen;
}

//Funktion zum prüfen ob schon einer gewonnen hat
//Übergabeparameter Zeiger auf char Array und Spielstein
bool is_winner(char *arr,const char zeichen)
{
   //Alle Positionen die abgefragt werden müssen
   //nacheinander im array pos
   //Jeweils 3 Positionen * 8 (x Achse 3, Y Achse 3 und diagonal 2 = 8)
   //0,1,2 z.B. für oberste Reihe x Achse von links nach rechts
   //2,4,6 für Diagonal rechts oben nach links unten
   const short pos[24]={0,1,2,3,4,5,6,7,8,0,3,6,1,4,7,2,5,8,0,4,8,2,4,6};
   //Hilfszählvariable c
   short c;
   //8 Linien müssen abgefragt werden (1.-3. von links nach rechts,1.-3. von oben nach unten
   //und 2 mal diagonal
   for(int x=0;x<8;x++)
   {
      //Zähler auf Null
      c=0;
      //Wenn der Übergebene Spielstein(zeichen) an der jeweiligen Position steht
      //dann Zählvariable um 1 incrementieren
      for(int y=0;y<3;y++) if(arr[pos[y+(x*3)]]==zeichen) c++;
      //Wenn (>2 heisst also 3) Spielsteine in der Linie gefunden dann true zurück (Der Spieler hat gewonnen)
      if(c>2) return true;
   }
   //sonst false zurück (noch keiner gewonnen)
   return false;
}

int main(int argc, char* argv[])
{
   //Spielfeld (3*3=9 Spielfelder)
   char ttt[3][3];
   //Zwei verschiedene Spielsteine stone[0]='X' stone[1]='O'
   const char stones[2]={'X','O'};
   //Welcher Spieler ist gerade dran false = Spieler stones[0]
   //true = Spieler stones[1]
   bool player=false;
   //char für Tastatureingabe
   char eingabe;
   //Unendlich lange durchlaufen
   while (true)
   {
      //Spielfeld 'zeichnen' und char Array initialisieren
      spielfeld(ttt[0]);
      //Fragen wer anfängt
      gotoxy(0,10);
      cout << "Wer faengt an (X oder O) ?";
      //Solange eingabe!='x' bzw 'o' weiter Tastatur abfragen
      //tolower wandelt eventuelle Grossbuchstaben in kleine um
      while(tolower(eingabe)!='x'&&tolower(eingabe)!='o') eingabe=getch();
      //Wenn eingabe = 'o' dann stones[1] true=1
      if(eingabe=='o') player = true;
      //sonst stones[0] false = 0
      else player = false;
      //Solange der letzte Steinewerfer noch nicht gewonnen hat
      //und das Feld noch nicht voll ist
      while(!is_winner(ttt[0],stones[!player])&&!gestoned(ttt[0],0,0,true))
      {
         //Anzeige wer dran ist
         gotoxy(0,10);
         cout << "Spieler '" << stones[player] << "' ist an der Reihe !";
         //Spieler Spielstein setzen lassen
         set_stone(ttt[0],stones[player]);
         //Spieler switchen 0=1 1=0
         player=!player;
      }
      //Mit Cursor an Meldungsposition
      gotoxy(0,10);
      //Wenn wir aus der Schleife gelaufen sind weil einer gewonnen hat
      //dann Anzeigen wer gewonnen hat
      if(is_winner(ttt[0],stones[!player])) cout << "Spieler '" << stones[!player] << "' hat gewonnen !     ";
      //Wenn keiner gewonnen hat dann muss ja das Spielfeld voll sein
      //Also unentschieden melden
      else if(gestoned(ttt[0],0,0,true)) cout << "Das Spiel ist unentschieden ! ";
      //Nochmal spielen
      gotoxy(0,12);
      cout << "nochmal (j/n) ?";
      //Solange eingabe ungleich 'n' und eingabe ungleich 'j'
      while(tolower(eingabe)!='n'&&tolower(eingabe)!='j') eingabe=getch();
      //Wenn 'n' gedrückt dann raus aus der Endlosschleife
      if(tolower(eingabe)=='n') break;
      //Sonst gehts wieder weiter mit dem nächsten Spiel
   }
   //Windows mitteilen das alles ok ist.
   return 0;
}

ich hab mir als ich angefangen habe auch mal ein kleines programm geschrieben, dass ordner durchsucht um bestimmte files zu archivieren. da kann man dann später auch noch schön ein GUI dazumachen.

Fussel

#include "ic.hpp" ??
was isn das?
die datei ist im sdk set nicht dabei
wo finde ich die?

danke für:

//Bildschirm löschen
clrscr();
//Cursor an oberste linke Position
gotoxy(0,0);

das kannte ich noch nicht, werde ich wohl einbaun
wenn man den bildschirm gelöscht hat, ist der curser doch automatisch oben links oder nicht?

http://web56.hermes.server-pool.de/pages/ic.c-plusplus.net/

wenn man den bildschirm gelöscht hat, ist der curser doch automatisch oben links oder nicht?

kommt drauf an ob das bei der Improved Console so implementiert ist (Hab ich noch nicht getestet)

So wie es aussieht ist das nicht der Fall.
Kannst du aber doch in der Methode console.clear(...) leicht implementieren.
Setzt du da einfach ein

setCurPos(0,0);

mit rein. D.h. wenn Herr Sidewinder nichts dagegen hat.

mikey

Der Code nutzt die Improved Console. Einfach mal im DOS/Win32 Konsolenforum gucken.

mikey schrieb:

Der Code nutzt die Improved Console. Einfach mal im DOS/Win32 Konsolenforum gucken.

ach. ^^

Heute keine Brille auf ?

Chris++ 0

Also ich hab aus Langeweile mal einen mini Taschenrechner geschrieben der Lineare und Quadratische Funktionen berechnen konnte. Allerdings gingen nur die standard Formen und als Ergebnisse wurden nur die Nullstellen + Extrempunkte berechnet.

Was ich dir aber empfehlen kann ist, einen "Formelrechner" zu schreiben. In den gibst du dann Funktionen wie "3+(2-1)-4+x" ein, und der rechnet dir dann das Ergebnis aus. Für x kam dann bei mir noch eine Abfrage welchen Wert diese Variable hätte. Ich musste das damals für einen Einstellungstest schreiben. Allerdings brauchte ich nur die Operatoren +-/ implementieren. Im Studium lernst du eventl. sogar noch eine richtig elegante Variante für das Problem. Ich glaub das war die Postfix Notation.

Naja ich brauch nicht erwähnen das das von mir ne ganz schöne frickelei war. Aber es hat funktioniert und mir meine Ausbildung ermöglicht

Brutus

Das hatten doch die HP-Taschenrechner, oder?
Damit waren die Leute viel schneller als mit normaler Infixnotation.

Mr. Pink

ist postfix die umgekehrt polnische notation?
mein éhemaliger info-lehrer meinte mal, dass man damit parser eleganter und schneller machen kann.

thordk

Mr. Pink schrieb:

ist postfix die umgekehrt polnische notation?
mein éhemaliger info-lehrer meinte mal, dass man damit parser eleganter und schneller machen kann.

jup, ist es und ja, hat er recht wenn nen term in UPN vorliegt, muss man ihn nur genau so, wie man ihn einliest, auf nen stack schreiben und jedesmal, wenn man auf nen operator trifft die jeweilige anzahl an operanden aus dem stack holen, mit dem operator verknüpfen und wieder reinstecken.

überprüfung auf syntaktische korrektheit geschieht dabei ganz automatisch (wenn man kurz drüber nachdenkt, merkt man auch warum)

thordk

toll, was man so alles macht, wenn einem fad is ^^

import java.util.Stack;
import java.util.StringTokenizer;

class UPN
{
	private static Stack<Double> stack = null;

	public static Double parse(String upnTerm) {
		stack = new Stack<Double>();

		StringTokenizer st = new StringTokenizer(upnTerm, " ");
		while(st.hasMoreTokens()) {
			String atom = st.nextToken();
			if(atom.equals("+")) {
				Double rhs = stack.pop();
				Double lhs = stack.pop();
				stack.push(lhs + rhs);
			}
			else if(atom.equals("-")) {
				Double rhs = stack.pop();
				Double lhs = stack.pop();
				stack.push(lhs - rhs);
			}
			else if(atom.equals("*")) {
				Double rhs = stack.pop();
				Double lhs = stack.pop();
				stack.push(lhs * rhs);
			}
			else if(atom.equals("/")) {
				Double rhs = stack.pop();
				Double lhs = stack.pop();
				stack.push(lhs / rhs);
			}
			else {
				stack.push(Double.parseDouble(atom));
			}
		}

		return stack.pop();
	}
}

public class Testing
{
	public static void main(String args[]) {
		System.out.println( UPN.parse("3 4 + 5 *") );
	}
}

ein UPN parser in java. verdammt kurz oder? und man könnt den sogar noch kürzer machen, wenn man wollte.

Brutus

"Java", "wollen".
Hmm, irgendetwas stimmt da nicht.

Badestrand

Java ist schon relativ elegant, da ist was dran

class UPN
{
    public static Double parse(String upnTerm)
    {
    	Stack<Double> stack = new Stack<Double>();
        StringTokenizer st = new StringTokenizer(upnTerm, " ");
        while(st.hasMoreTokens())
        {
            String atom = st.nextToken();
            if(atom.equals("+"))
                stack.push(stack.pop() + stack.pop());
            else if(atom.equals("-"))
                stack.push( (-1)*(stack.pop()-stack.pop()));
            else if(atom.equals("*"))
                stack.push( stack.pop()* stack.pop());
            else if(atom.equals("/"))
            	stack.push( 1 / (stack.pop() / stack.pop()) );
            else
                stack.push(Double.parseDouble(atom));
        }
        return stack.pop();
    }
}

uff, hatteste Recht thordk