UCM _ Grado en Desarrollo de Videojuegos _ Fundamentos de Programación _ Codigos_ra

Esta es una vista previa del archivo. Inicie sesión para ver el archivo original

Códigos/Arbol navidad.csusing System;
namespace arbolNavidad
{
	class MainClass
	{
		// solicita altura del arbol, que debe estar en el intervalo [min,max]
		public static int pideAltura (int min, int max){
			int alt;
			Console.Write ("Altura del arbol: ");
			alt = int.Parse (Console.ReadLine ());
			while (alt<min || alt>max) {	
				Console.Write ("Altura inválida. Debe estar entre {0} y {1}\n", min, max);
				Console.Write ("Altura del arbol: ");		
				alt = int.Parse (Console.ReadLine ());
			}
			return alt;
		}
		// escribe n veces el texto s
		public static void repiteTexto (int n, string s){
			int i;
			for (i=0; i<n; i++) 
				Console.Write (s);
		}
		// numero de blancos en un nivel para un arbol de altura alt
		public static int numBlancos (int alt, int nivel){
			return nivel -alt;
		}
		// numero de asteriscos en un nivel para un arbol de altura alt
		public static int numAsteriscos (int alt, int nivel){
			return nivel*2-1;
		}
		// dibuja el nivel "nivel" de un arbol de altura alt
		public static void dibujaNivel(int alt, int nivel){
			// dibujamos blancos
			repiteTexto (numBlancos (alt, nivel), "·");
			// dibujamos asteriscos
			repiteTexto (numAsteriscos (alt, nivel), "*");
			// salto de linea
			Console.WriteLine ();
		}
		// metodo ppal
		public static void Main ()
		{
			int alt, nivel;
			alt = pideAltura (0, 30);
			nivel = 1;
			while (nivel <= alt) {
				dibujaNivel (alt, nivel);
				nivel++;
			}
		}
	}
}
Códigos/bisiesto.csusing System;
namespace bisiesto
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			int anio;
			bool bis;
			Console.Write ("Dame un año: ");
			anio = int.Parse(Console.ReadLine ());
			bis = (anio % 4 == 0) && ((anio % 100 != 0) || (anio % 400 == 0));
			Console.WriteLine ("Bisiesto: " + bis);
		}
	}
}
Códigos/claseListaEnlazada.cs	class MainClass
	{
		//static void verLista(Lista l){
		public static void Main (string[] args)
		{
			Lista l = new Lista ();
			for (int i = 0; i < 5; i++) {
				l.insertaIni (i);
				l.insertaFin (i + 7);
			}
			//verLista (l);
		}
	}
	class Lista{
		class Nodo{
			public int dato;
			public Nodo sig; // enlace al siguiente nodo
			// constructora
			public Nodo(int e){ dato = e;}
		}
		// atributos de la lista enlazada: referencia al primero y al último
		Nodo pri, ult;
		// constructora de listas
		public Lista(){
			pri = ult = null;
		}
		// obtener primer elto de la lista
		public void primero(out int e){
			if (pri==null) throw new Exception("primero en lista vacia");
			e = pri.dato;
		}
		// obtener ultimo elto de la lista
		public void ultimo(out int e){
			if (ult==null) throw new Exception("ultimo en lista vacia");
			e = ult.dato; 
		}
		// ver si un elto esta en la lista
		public bool esta(int e){
			Nodo aux= pri;
			// busqueda: avanzazmos con aux mientras no llegemoa al final y no encontremos elto
			while (aux!=null && aux.dato!=e) aux=aux.sig;
			// si no hemos llegado el final, es pq el elto está en la lista
			return (aux!=null);
		}
		// insertar elto al ppio de la lista
		public void insertaIni(int x){
			// si la lista es vacia creamos nodo y apuntamos a el pri y ult
			if (pri == null) {
				pri = new Nodo (x);
				pri.sig = null;
				ult = pri;
			} else { // si no es vacia creamos nodo y lo enganchamos al ppio
				Nodo aux = new Nodo(x);
				aux.sig = pri;
				pri = aux;
			}
		}
		// insertar elto al final de la lista
		public void insertaFin(int x){
			// si es vacia creamos nodo y apuntamos a el ppi y ult
			if (pri == null) {
				pri = new Nodo (x);
				pri.sig = null;
				ult = pri;
			} else {
				// si no, creamos nodo apuntado por ult.sig y enlazamos
				ult.sig = new Nodo (x);
				ult = ult.sig;
				ult.sig = null;
			}
		}
		// elimina elto dado de la lista, si esta
		public void eliminaElto(int x){
			// lista vacia
			if (pri==null) throw new Exception("Elimina elto en lista vacia");
			else {
				// eliminar el primero
				if (x == pri.dato) {
					// si solo tienen un elto
					if (pri == ult)
						pri = ult = null;
					// si tiene más de uno
					else
						pri = pri.sig;
				}
				// eliminar otro distino al primero
				else {
					// busqueda 
					Nodo aux = pri;
					// recorremos lista buscando el ANTERIOR al que hay que eliminar (para poder luego enlazar)
					while (aux.sig != null && x!=aux.sig.dato)				
						aux = aux.sig;
					// si lo encontramos
					if (aux.sig != null) {
						// si es el ultimo cambiamos referencia al ultimo
						if (aux.sig == ult)
							ult = aux;
						// puenteamos
						aux.sig = aux.sig.sig;
					}
				}
			}
		}
		public void eliminaIni(){
			if (pri == null)
				throw new Exception ("EliminaIni en lista vacia");
			else if (pri == ult)
				pri = ult = null;
			else
				pri = pri.sig;
		}
	}
Códigos/Criba Erastótenes.csusing System;
namespace cribaEratostenes
{
	class MainClass
	{
		
		public static void Main ()
		{	
			int n = pideDato ("Límite: ", 2, 99999); 
			int[] v = inicia(n);
			primos(v);
			escribePrimos(v);
			
		}
		// devuelve el vector |2|3|4|...|n|
		static int [] inicia(int n){
			int[] v = new int[n-1];
			for (int i=0;i<n-1;i++) v[i]=i+2;
			return v;
		}
		static void filtra(int [] v, int pri){
			for (int i = pri+1; i < v.Length; i++)
				if (v [i] % v [pri] == 0)
					v [i] = 0;
		}
		static int sigPrim(int [] v, int from){
			while (from < v.Length && v [from] == 0)
				from++;
			return from;
		}
		static void primos(int [] v){
			int from = 0;
			while (from<v.Length){
				filtra (v, from);
				from = sigPrim (v, from + 1);
			}
		}
		static void escribePrimos(int [] v){
			for (int i = 0; i < v.Length; i++)
				if (v[i]!=0) Console.Write (v [i] + " ");
		}
		static int pideDato(string texto, int min, int max){			
			int dato = min - 1; // valor "por defecto" no válido
			// para forzar entrada en bucle
			while (dato < min || dato > max) { // mientras no valido
				Console.Write ("{0} [{1},{2}]: ", texto, min, max);
				dato = int.Parse (Console.ReadLine ());
			} // fin while
			return dato;
		}
	}
}
Códigos/Ejemplos de recursión.csusing System;
namespace recursion
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			/*
			for (int i=1; i<10; i++)
				Console.WriteLine ("fib " + i + "= " + fib2(i));
				*/
			// Console.WriteLine (mcd(12,30));
			//hanoi(3,'a','b','c');
			TimeSpan start, stop;
			long n = 15;
			start = new TimeSpan(DateTime.Now.Ticks);
			Console.WriteLine ("fact " + n + "= " + fact(n));		
			stop = new TimeSpan(DateTime.Now.Ticks);
			Console.WriteLine("Tiempo: " + stop.Subtract(start).TotalMilliseconds);		
			start = new TimeSpan(DateTime.Now.Ticks);
			Console.WriteLine ("factFin " + n + "= " + factRecFinal(n));		
			stop = new TimeSpan(DateTime.Now.Ticks);
			Console.WriteLine("Tiempo: " + stop.Subtract(start).TotalMilliseconds);		
		}
		// factorial recursivo: versión elemental (no rec final)
		static long fact(long n){
			if (n == 0)
				return 1;
			else
				return n * fact (n - 1);
		}
		// generalización con acumulador de resultado para conseguir rec final
		static long factRecFinal(long n, long ac){
			if (n == 0)
				return ac;
			else
				return factRecFinal (n - 1, ac * n);
		}
		// factorial recursivo final
		static long factRecFinal(long n){
			return factRecFinal(n,1);
		}
		static int mcd(int a, int b){
			if (b == 0)
				return a;
			else
				return mcd (b, a % b);
		}
		// fib recursivo version elemental
		static int fib(int n){
			if (n == 1 || n == 2)
				return 1;
			else
				return fib (n - 1) + fib (n - 2);
		}
		// fib rec final: generalizacion
		static int fibFin(int a, int b, int n){
			if (n==0) return b;
			else return fibFin(b,a+b,n-1);
		}
		// fib con algoritmo mejorado y además rec final
		static int fibFin(int n){
			if (n==1 || n==2) return 1;
			else return fibFin(1,1,n-2);
		}
		// torres de hanoi
		static void hanoi(int n, char ori, char aux, char des){
			if (n > 0) {
				hanoi (n - 1, ori, des, aux);
Console.WriteLine (ori + " -> " + des);
				hanoi (n - 1, aux, ori, des);
			}
		}
		// generalización del método de busqueda binaria 
		static bool busqBin(int e, int [] v, int ini, int fin){
			// caso base 1: los índices de cruzan -> el elto no está
			if (ini > fin)
				return false;
			else {
				// posición media
				int m = (ini + fin) / 2;
				// caso base 2: se encuentra el elto
				if (v [m] == e)
					return true;
				// búsqueda en la mitad correspondiente
				else if (e < v [m])	return busqBin (e, v, ini, m - 1);
				else return busqBin (e, v, m + 1, fin);
			}
		}
		// busqueda binaria de un elto e en un vector ordenado v 
		static bool busqBin(int e, int [] v){
			return busqBin (e, v, 0, v.Length);
		}
		// potencia x^y
		static int potencia(int x, int y){
			if (y == 0)
				return 1;
			else
				return x * potencia (x, y - 1);			
			}	
		// recursion mutua		
		static bool par(int n){
			if (n == 0)
				return true;
			else
				return impar (n - 1);
		}
		static bool impar(int n){
			if (n == 0)
				return false;
			else
				return par (n - 1);
		}
	}	
}
Códigos/Examen febrero.csusing System;
namespace masterMind
{
	class MainClass
	{
		const int N = 4;
		public static Random rnd = new Random();
		public static void Main (string[] args)
		{
			int[] combJug = new int [N];
			//int[] combSecr = {3,6,1,6};
			//int[]combSecr = {2,6,4,5};
			//int[] combSecr = {1,6,4,0};
			int[] combSecr = new int [N];
			generaComb (combSecr);	
			// Depuracion: para ver la comb secreta
			/*
			for (int i = 0; i < combSecr.Length; i++)
				Console.Write (combSecr [i]);
			Console.WriteLine();
			*/
			int intento = 0, muertos = 0, heridos;
			while (muertos < N) {
				leeCombinacion (combJug);
				evalua (combSecr, combJug, out muertos, out heridos);
				Console.Write ("Muertos: {0} Heridos: {1}\n\n", muertos, heridos);
				intento++;
			}
			Console.WriteLine ("Has necesitado {0} intentos", intento);
		}
		public static void generaComb(int [] comb){
			int [] v = {5,3,1,9,6,0,2,8,4,7};	
			int i = rnd.Next (0, 10-N+1); // valor aleatorio en [0,10-N]
			for (int j = 0; j < 4; j++)
				comb [j] = v [i + j];
			}
		public static bool muerto(int [] combSecr, int [] combJug, int pos){
			return combSecr [pos] == combJug [pos];
		}
		public static bool herido(int [] combSecr, int [] combJug, int pos){
			bool her;
			// si es muerto fin, no esta herido
			if (muerto (combSecr, combJug, pos))
				her= false;
			else {
				// si no, búsqueda de en el vector (no es necesario exlcuir la propia posicion pos)
				int i = 0;
				while (i < N && combJug [pos] != combSecr [i])
					i++;
				her = i<N;
			}
			return her;
		}
		public static void evalua(int [] combSecr, int [] combJug, out int m, out int h){
			m = h = 0;
			for (int i=0; i<N; i++){
				if (muerto(combSecr, combJug, i)) m++;
				else if (herido(combSecr, combJug, i)) h++;
			}	
		}
		public static void leeCombinacion(int [] combJug){
			Console.Write ("Tu combinacion ({0} digitos): ", N);
			int c = int.Parse (Console.ReadLine ());
			for (int i = N - 1; i>=0; i--){
				combJug [i] = c % 10;
				c = c / 10;			
			}
		}
		/*
		public static int dameDig(bool [] usados){
			int i;
			do {
				i = rnd.Next (0, 10);
			} while(usados [i]);
			usados [i] = true;
			return i;
		}
			
		public static void generaComb(int [] comb){
			bool[] usados = new bool[10];
			for (int i = 0; i < N; i++)
				usados [i] = false;
			for (int i = 0; i < N; i++) {
				comb [i] = dameDig (usados);
			}
		}
		*/
		public static void generaCombinacion2(int [] comb){
			Random rnd = new Random();
			// vector de dígitos 0..9
			int[] v = new int[10];
			// rellenamos con 0..9
			for (int i = 0; i < 10; i++)
				v [i] = i;
			// permutamos: intercambiamos cada posicion i=0..9 con otra aleatoria en 0..9
			for (int i = 0; i < 10; i++) {
				int j = rnd.Next (0, 10);
				int tmp = v [i];
				v [i] = v [j];
				v [j] = tmp;
			}
			// nos quedamos con los N primeros
			for (int i=0; i<N; i++) 
				comb[i]=v[i];
		}
	}
}
Códigos/monedas.csusing System;
namespace monedas
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			int b500, b200, b100, b50, b20, b10, b5, m2, m1, m50c, 
			 m20c, m10c, m5c, m2c, m1c, centimos;
			Console.Write ("Cuánto dinero quieres? (\"euros,centimos\"): ");
			// convertimos la cantidad a céntimos para trabajar con enteros
			// y aritmética modular
			// Para convertir a entero utilizamos Round y un casting (int) Math.Round()
			// para evitar errores de redondeo
			centimos = (int) Math.Round(100 * double.Parse (Console.ReadLine ()));		
			b500 = centimos/50000;
			centimos = centimos % 50000;
			b200 = centimos/20000;
			centimos = centimos % 20000;
			b100 = centimos/10000;
			centimos = centimos % 10000;
			b50 = centimos/5000;
			centimos = centimos % 5000;
			b20 = centimos/2000;
			centimos = centimos % 2000;
			b10 = centimos/1000;
			centimos = centimos % 1000;
			b5 = centimos/500;
			centimos = centimos % 500;
			m2 = centimos/200;
			centimos = centimos % 200;
			m1 = centimos/100;
			centimos = centimos % 100;
			m50c = centimos/50;
			centimos = centimos % 50;
			m20c = centimos/20;
			centimos = centimos % 20;
			m10c = centimos/10;
			centimos = centimos % 10;
			m5c = centimos/5;
			centimos = centimos % 5;
			m2c = centimos/2;
			centimos = centimos % 2;
					
			m1c = centimos;
			Console.WriteLine ("Tu cambio: \n" +
				"Billetes de 500: " + b500 + "\n" +
				"Billetes de 200: " + b200 + "\n" +
				"Billetes de 100: " + b100 + "\n" +
				"Billetes de 50: " + b50 + "\n" +
				"Billetes de 20: " + b20 + "\n" +
				"Billetes de 10: " + b10 + "\n" +
				"Billetes de 5: " + b5 + "\n" +
				"Monedas de 2: " + m2 + "\n" +
				"Monedas de 1: " + m1 + "\n" +
				"Monedas de 50c: " + m50c + "\n" +
				"Monedas de 20c: " + m20c + "\n" +
				"Monedas de 10c: " + m10c + "\n" +
				"Monedas de 5c: " + m5c + "\n" +
				"Monedas de 2c: " + m2c + "\n" +
				"Monedas de 1c: " + m1c + "\n");
		}
	}
}
Códigos/NkListaEnlazadaSnake.cs	class ListaEnlazada{
		class Nodo{
			public int x,y;
			public Nodo sig; // enlace al siguiente nodo
			// constructor 
			public Nodo(int i, int j){ x = i; y = j; }
		}
		// atributos de la lista enlazada: referencia al primero y al último		
		Nodo pri, ult, act;
		// constructora de listas
		public ListaEnlazada(){
			pri = ult = act = null;
		}
		// obtener primer elto de la lista
		public void primero(out int i, out int j){
			if (pri==null) throw new Exception("Error primero: lista vacia");
			i = pri.x; j=pri.y;
		}
		// obtener ultimo elto de la lista
		public void ultimo(out int i, out int j){
			if (ult==null) throw new Exception("Error ultimo: lista vacia");
			i = ult.x; j=ult.y;
		}
			
		// ver si un elto esta en la lista
		public bool esta(int i, int j){
			// iniciamos con aux al ppio
			Nodo aux = pri;
			// busqueda: avanzazmos con aux mientras no llegemoa al final y no encontremos elto
			while (aux!=null && (aux.x!=i || aux.y!=j)) aux=aux.sig;
			// si no hemos llegado el final, es pq el elto está en la lista
			return (aux!=null);
		}
		// insertar elto al ppio de la lista
		public void insertaIni(int x, int y){
			// si la lista es vacia creamos nodo y apuntamos a el pri y ult
			if (pri == null) {
				pri = new Nodo (x,y);
				pri.sig = null;
				ult = pri;
			} else { // si no es vacia creamos nodo y lo enganchamos al ppio
				Nodo aux = new Nodo(x,y);
				aux.sig = pri;
				pri = aux;
			}
		}
		// insertar elto al final de la lista
		public void insertaFin(int x, int y){
			// si es vacia creamos nodo y apuntamos a el ppi y ult
			if (pri == null) {
				pri = new Nodo (x,y);
				pri.sig = null;
				ult = pri;
			} else { // si no, creamos nodo apuntado por ult.sig y enlazamos
				ult.sig = new Nodo (x, y);
				ult = ult.sig;
				ult.sig = null;
			}
		}
		//
elimina elto dado de la lista, si esta
		public void eliminaElto(int x, int y){
			// lista vacia
			if (pri==null) throw new Exception("Error eliminaElto: lista vacia");
			else {
				// eliminar el primero
				if (x == pri.x && y == pri.y) {
					// si solo tiene un elto
					if (pri == ult)
						pri = ult = null;
					// si tiene más de uno
					else
						pri = pri.sig;
				}
				// eliminar otro distinto al primero
				else {
					// busqueda. aux al ppio
					Nodo aux = pri;
					// recorremos lista buscando el ANTERIOR al que hay que eliminar (para poder luego enlazar)
					while (aux.sig != null && (x!=aux.sig.x || y!=aux.sig.y))				
						aux = aux.sig;
					// si lo encontramos
					if (aux.sig != null) {
						// si es el ultimo cambiamos referencia al ultimo
						if (aux.sig == ult)
							ult = aux;
						// puenteamos
						aux.sig = aux.sig.sig;
					}
				}
			}
		}
		// elimina primer elto de la lista
		public void eliminaIni(){
			if (pri==null) throw new Exception("Error eliminaIni: lista vacia");
			if (pri == ult)	pri = ult = null;
			else pri=pri.sig;
		}
			
		// inicizlización del iterador. Lo colocamos al ppio
		public void iniciaRecorrido(){
			act = pri;
		}
		public bool dame_actual_y_avanza(out int x, out int y){
			x = y = 0;
			// si estamos al final, ya no hay actual y devolvemos false
			if (act == null)
				return false;
			else { // si no, info del nodo, avanzamos act y devolvemos true
				x = act.x;
				y = act.y;
				act = act.sig;
				return true;
			}
		}
		/* auxiliar solo para depuración
		public void verLista(){
			Console.Write ("Lista: ");
			Nodo aux = pri;
			while (aux != null) {
				Console.Write ("(" + aux.x + "," + aux.y + ") ");
				aux = aux.sig;
			}
			Console.Write ("\n\n");
		}
		*/
	}
Códigos/NkSnake.csusing System;
namespace Practica4
{
 enum Dir { Norte, Sur, Este, Oeste, Null };
 class MainClass
 {
 public static void Main(string[] args)
 {
 int alto = 5;
 int ancho = 4;
 int cont = 0;
 Estado estado = new Estado(ancho, alto);
 bool partida = true;
 estado.dibuja();
 while (partida)
 {
 if (cont == 25)
 {
 estado.ponFruta();
 cont = 0;
 }
 Dir d = leeEntrada();
 estado.cambiaDir(d);
 partida = estado.avanza();
 estado.dibuja();
 cont++;
 System.Threading.Thread.Sleep(500);
 }
 if (!partida)
 {
 throw new Exception ("Te has chocado");
 //Console.WriteLine(Exception);
 }
 Console.ReadLine();
 }
 static Dir leeEntrada()
 {
 Dir d = Dir.Null;
 if (Console.KeyAvailable)
 {
 string tecla = Console.ReadKey().Key.ToString();
 switch (tecla)
 {
 case "LeftArrow":
 d = Dir.Oeste;
 break;
 case "UpArrow": 
 d = Dir.Norte; 
 break;
 case "RightArrow": 
 d = Dir.Este;
 break;
 case "DownArrow": 
 d = Dir.Sur;
 break;
 }
 while (Console.KeyAvailable)
 (Console.ReadKey(false)).KeyChar.ToString();
 }
 return d;
 }
 }
 class Estado
 {
 static Random rnd = new Random();
 public int fils, cols;
 ListaEnlazada serp = new ListaEnlazada();//el primer nodo es la cola y el ultimo la cabeza
 ListaEnlazada frutas = new ListaEnlazada();
 public int dirx, diry;
 public Estado(int ancho, int alto)
 {
 serp = new ListaEnlazada();
 frutas = new ListaEnlazada();
 cols = ancho;
 fils = alto;
 serp.insertaIni(ancho / 2, alto / 2);//se crea la serpiente, solo la cabeza
 dirx = 1;
 diry = 0;
 }
 public bool colision(int x, int y)
 {
 if (x == 0 || x > fils || y == 0 || y > cols)
 {//choque con los muros
 //throw new Exception("Has chocado con el muro");
 return true;
 }
 else if (serp.esta(x, y))
 {//choque con la serpiente
 //throw new Exception("Has chocado con la serpiente");
 return true;
 }
 else
 return false;
 }
 public bool avanza()
 {
 int i, j;
 serp.ultimo(out i, out j);//localizamos la cabeza de la serpiente 
 if (!colision(i + dirx, j + diry))
 {//si no hay colision comprobamos si en la siguiente unidad hay una fruta
 if (frutas.esta(i + dirx, j + diry))
 {//añidimos el nodo de cabeza para que aumente de tamaño y la cabeza pase al siguiente nodo
 serp.insertaFin(i + dirx, j + diry);
 frutas.eliminaElto(i + dirx, j + diry);
 }
 else
 { //si no hay fruta, eliminamos el nodo de la cola y añadimos una cabeza en la direccion 
 serp.insertaFin(i + dirx, j + diry);
 serp.eliminaIni();
 }
 return true;
 }
 else
 return false;
 } 
 //controla las direcciones que puede tomar la serpiente
 public void cambiaDir(Practica4.Dir dir)
 {
 switch (dir)
 {
 case Practica4.Dir.Este:
 dirx = 1;
 diry = 0;
 break;
 case Practica4.Dir.Norte:
 dirx = 0;
 diry = -1;
 break;
 case Practica4.Dir.Oeste:
 dirx = -1;
 diry = 0;
 break;
 case Practica4.Dir.Sur:
 dirx = 0;
 diry = 1;
 break;
 case Practica4.Dir.Null:
 break;
 }
 }
 //coloca frutas en el tablero mientras este la serpiente
 public void ponFruta()
 {
 int x, y;
 do
 {
 x = rnd.Next(1, fils);
 y = rnd.Next(1, cols);
 } while (serp.esta(x, y) || frutas.esta(x, y));
 frutas.insertaIni(x, y);
 }
 public void dibuja()
 {
 Console.BackgroundColor = ConsoleColor.Black;
 Console.Clear();
 Console.SetCursorPosition(0, 0);
 dibujaTablero();
 dibujaSerp();
 dibujaFrutas();
 }
 //dibuja los bordes del tablero con los que puede chocar la serpiente
 public void dibujaTablero()
 {
 dibujaFils();
 Console.WriteLine();
 for (int x = 0; x <= cols; x++)
 {
 Console.BackgroundColor = ConsoleColor.Red;
 Console.Write(" ");
 Console.SetCursorPosition(2 * fils+2, x);
 Console.WriteLine(" ");
 }
 dibujaFils();
 }
 public void dibujaFils()
 {
 Console.BackgroundColor = ConsoleColor.Red;
 for (int x = 0; x <= fils+1; x++)
 Console.Write(" ");
 }
 //dibuja la serpiente
 public void
dibujaSerp()
 {
 int x, y;
 serp.iniciaRecorrido();
 Console.BackgroundColor = ConsoleColor.DarkYellow;
 Console.ForegroundColor = ConsoleColor.Black;
 while (serp.dame_actual_y_avanza(out x, out y))
 {
 Console.SetCursorPosition(2 * x, y);//2*x para que sea cuadrado cada parte de la serpiente
 Console.Write(" ");
 }
 //dibujamos la cabeza de la serpiente
 serp.ultimo(out x, out y);
 Console.SetCursorPosition(2 * x, y);
 Console.Write("<>");
 }
 //dibuja la fruta
 public void dibujaFrutas()
 {
 int x, y;
 frutas.iniciaRecorrido();
 while (frutas.dame_actual_y_avanza(out x, out y))
 {
 Console.SetCursorPosition(2 * x, y);
 Console.BackgroundColor = ConsoleColor.Green;
 Console.Write(" ");
 }
 }
 }//Fin de la clase Estado
 class ListaEnlazada
 {
 class Nodo
 {
 public int x, y;
 public Nodo sig; // enlace al siguiente nodo
 // constructor 
 public Nodo(int i, int j) { x = i; y = j; }
 }
 // atributos de la lista enlazada: referencia al primero y al último		
 Nodo pri, ult, act;
 // constructora de listas
 public ListaEnlazada()
 {
 pri = ult = act = null;
 }
 // obtener primer elto de la lista
 public void primero(out int i, out int j)
 {
 if (pri == null) throw new Exception("Error primero: lista vacia");
 i = pri.x; j = pri.y;
 }
 // obtener ultimo elto de la lista
 public void ultimo(out int i, out int j)
 {
 if (ult == null) throw new Exception("Error ultimo: lista vacia");
 i = ult.x; j = ult.y;
 }
 // ver si un elto esta en la lista
 public bool esta(int i, int j)
 {
 // iniciamos con aux al ppio
 Nodo aux = pri;
 // busqueda: avanzazmos con aux mientras no llegemoa al final y no encontremos elto
 while (aux != null && (aux.x != i || aux.y != j)) aux = aux.sig;
 // si no hemos llegado el final, es pq el elto está en la lista
 return (aux != null);
 }
 // insertar elto al ppio de la lista
 public void insertaIni(int x, int y)
 {
 // si la lista es vacia creamos nodo y apuntamos a el pri y ult
 if (pri == null)
 {
 pri = new Nodo(x, y);
 pri.sig = null;
 ult = pri;
 }
 else
 { // si no es vacia creamos nodo y lo enganchamos al ppio
 Nodo aux = new Nodo(x, y);
 aux.sig = pri;
 pri = aux;
 }
 }
 // insertar elto al final de la lista
 public void insertaFin(int x, int y)
 {
 // si es vacia creamos nodo y apuntamos a el ppi y ult
 if (pri == null)
 {
 pri = new Nodo(x, y);
 pri.sig = null;
 ult = pri;
 }
 else
 { // si no, creamos nodo apuntado por ult.sig y enlazamos
 ult.sig = new Nodo(x, y);
 ult = ult.sig;
 ult.sig = null;
 }
 }
 // elimina elto dado de la lista, si esta
 public void eliminaElto(int x, int y)
 {
 // lista vacia
 if (pri == null) throw new Exception("Error eliminaElto: lista vacia");
 else
 {
 // eliminar el primero
 if (x == pri.x && y == pri.y)
 {
 // si solo tiene un elto
 if (pri == ult)
 pri = ult = null;
 // si tiene más de uno
 else
 pri = pri.sig;
 }
 // eliminar otro distinto al primero
 else
 {
 // busqueda. aux al ppio
 Nodo aux = pri;
 // recorremos lista buscando el ANTERIOR al que hay que eliminar (para poder luego enlazar)
 while (aux.sig != null && (x != aux.sig.x || y != aux.sig.y))
 aux = aux.sig;
 // si lo encontramos
 if (aux.sig != null)
 {
 // si es el ultimo cambiamos referencia al ultimo
 if (aux.sig == ult)
 ult = aux;
 // puenteamos
 aux.sig = aux.sig.sig;
 }
 }
 }
 }
 // elimina primer elto de la lista
 public void eliminaIni()
 {
 if (pri == null) throw new Exception("Error eliminaIni: lista vacia");
 if (pri == ult) pri = ult = null;
 else pri = pri.sig;
 }
 // inicizlización del iterador. Lo colocamos al ppio
 public void iniciaRecorrido()
 {
 act = pri;
 }
 public bool dame_actual_y_avanza(out int x, out int y)
 {
 x = y = 0;
 // si estamos al final, ya no hay actual y devolvemos false
 if (act == null)
 return false;
 else
 { // si no, info del nodo, avanzamos act y devolvemos true
 x = act.x;
 y = act.y;
 act = act.sig;
 return true;
 }
 }
 /* auxiliar solo para depuración
 public void verLista(){
 Console.Write ("Lista: ");
 Nodo aux = pri;
 while (aux != null) {
 Console.Write ("(" + aux.x + "," + aux.y + ") ");
 aux = aux.sig;
 }
 Console.Write ("\n\n");
 }
 */
 }
}
Códigos/otrapec.cs/// PRÁCTICA 3 - INTEGRANTES:
/// José María Monreal González
/// Alejandro Ortega Álvarez
/// Roberto Alcázar Morales
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZDFINAL
{
 class Program
 {
 //CONSTANTES
 const int ANCHO = 15, ALTO = 15;
 static Random rnd = new Random();
 public enum Color { rojo, cyan, verde, amarillo, azul, magenta };
 struct Posicion
 {
 public int x, y;
 }
 //Nuestro struct Visitados con el array posVis de tipo Posicion y los enteros pend y fin.
 struct Visitados
 {
 public Posicion[] posVis; 
 public int pend, fin;
 }
 //Método que genera de manera aleatoria utilizando el random ya declarado un color para cada casilla del tablero.
 public static void genera(Color[,] tab)
 {
 for (int i = 0; i < ANCHO; i++)
 {
 for (int j = 0; j < ALTO; j++)
 {
 tab[i, j] = (Color)rnd.Next(0, 6);
 }
 }
 }
 //Método encargado de pintar en pantalla el tablero y el panel de selección de colores, además del número de jugadas.
 public static void dibuja(Color[,] tab, int cont, int juego)
 {
 for (int i = 0; i < ALTO; i++)
 {
 for (int j = 0; j < ANCHO; j++)
 {
 switch (tab[i, j])
 {
 case Color.rojo:
 Console.BackgroundColor = ConsoleColor.Red;
break;
 case Color.cyan:
 Console.BackgroundColor = ConsoleColor.Cyan;
 break;
 case Color.verde:
 Console.BackgroundColor = ConsoleColor.Green;
 break;
 case Color.amarillo:
 Console.BackgroundColor = ConsoleColor.Yellow;
 break;
 case Color.azul:
 Console.BackgroundColor = ConsoleColor.Blue;
 break;
 case Color.magenta:
 Console.BackgroundColor = ConsoleColor.Magenta;
 break;
 }
 Console.Write(" ");
 }
 Console.WriteLine();
 }
 Console.Write("\n\n\n");
 //Dibujado del panel de control
 Console.BackgroundColor = ConsoleColor.Red;
 Console.Write(" 1 ");
 Console.BackgroundColor = ConsoleColor.Cyan;
 Console.Write(" 2 ");
 Console.BackgroundColor = ConsoleColor.Green;
 Console.Write(" 3 ");
 Console.WriteLine();
 Console.BackgroundColor = ConsoleColor.Yellow;
 Console.Write(" 4 ");
 Console.BackgroundColor = ConsoleColor.Blue;
 Console.Write(" 5 ");
 Console.BackgroundColor = ConsoleColor.Magenta;
 Console.Write(" 6 ");
 Console.WriteLine();
 
 //Al terminar restablecemos de nuevo el color por defecto de la consola (negro).
 Console.BackgroundColor = ConsoleColor.Black;
 //Escribimos por pantalla las jugadas dependiendo del modo de juego en el que nos encontremos.
 if (juego == 1)
 Console.Write("\n Jugadas Restantes: " + cont);
 else Console.Write("\n Jugadas Totales: " + cont);
 }
 //Método que comprueba si la posición dada (pos) se encuentra dentro del array posVis.
 static bool estaVisitado(Visitados vis, Posicion pos)
 {
 int i = 0;
 
 while ((i < vis.fin) && (pos.x != vis.posVis[i].x || pos.y != vis.posVis[i].y))
 i++;
 return (i != vis.fin);
 }
 //Añade las posiciones adyacentes de la posición dada en el caso de que no estén visitadas anteriormente.
 static void añadeVecinos(ref Visitados vis, Posicion pos)
 {
 Posicion aux = pos;
 aux.x = pos.x + 1;
 if (aux.x < ANCHO && !estaVisitado(vis, aux))
 {
 vis.posVis[vis.fin] = aux; 
 vis.fin++;
 }
 aux.x = pos.x - 1;
 if (aux.x >= 0 && !estaVisitado(vis, aux))
 {
 vis.posVis[vis.fin] = aux;
 vis.fin++;
 }
 //Reiniciamos la posición x a su valor inicial.
 aux.x = pos.x;
 aux.y = pos.y + 1;
 if (aux.y < ALTO && !estaVisitado(vis, aux))
 {
 vis.posVis[vis.fin] = aux;
 vis.fin++;
 }
 aux.y = pos.y - 1;
 if (aux.y >= 0 && !estaVisitado(vis, aux))
 {
 vis.posVis[vis.fin] = aux;
 vis.fin++;
 }
 }
 //Inicializa pend y fin de Visitados, además de declarar el array posVis. 
 //Este método contiene el algoritmode propagación del color que recorre el array posVis
 //y va coloreando las posiciones del tablero que correspondan.
 static void expande(Color[,] tab, Color nuevo)
 {
 
 Visitados vis;
 vis.posVis = new Posicion[ALTO * ANCHO];
 Posicion inicial;
 inicial.x = 0;
 inicial.y = 0;
 vis.posVis[0] = inicial;
 vis.pend = 0;
 vis.fin = 1;
 //Guardamos siempre en old el color antiguo de la casilla de referencia para la posterior comparación.
 Color old = tab[0, 0];
 //Mientras queden posiciones en el array posVis el algoritmo de propagación no termina.
 //El algoritmo hace una comprobación de la casilla a la que señala vis.pend y comprueba que no sea del color
 //que el jugador ha pulsado en el momento de la ejecución (nuevo) y que además sea el antiguo. 
 //Si esas dos condiciones se cumplen, "pintará" la casilla del nuevo color y añadirá sus casillas adyacentes al array posVis.
 while (vis.pend < vis.fin)
 {
 if (nuevo != tab[vis.posVis[vis.pend].x, vis.posVis[vis.pend].y] &&
 old == tab[vis.posVis[vis.pend].x, vis.posVis[vis.pend].y]) 
 {
 tab[vis.posVis[vis.pend].x, vis.posVis[vis.pend].y] = nuevo;
 añadeVecinos(ref vis, vis.posVis[vis.pend]);
 }
 vis.pend++;
 }
 }
 //Método encargado de devolver true/false si se ha terminado o no la partida.
 static bool finalPartida(Color[,] tab)
 {
 Color colorFinal = tab[0, 0];
 
 int i = 0, j = 0, cont = 0;
 
 while (i < ANCHO && colorFinal == tab[i, j])
 {
 while (j < ALTO && colorFinal == tab[i, j])
 {
 j++;
 cont++;
 }
 j = 0;
 i++;
 }
 return (cont == ALTO * ANCHO);
 }
 //Lee de teclado un número del 1-6 y lo convierte al color correspondiente (casting).
 static Color leeColor()
 {
 return (Color)(Console.ReadKey(true)).KeyChar - '0' - 1;
 }
 //MÉTODO PRINCIPAL
 static void Main(string[] args)
 {
 Color[,] tab = new Color[ANCHO, ALTO];
 int cont = 0;
 //Modos de juego:
 //CLÁSICO: Tienes un máximo de 30 movimientos para terminar la partida
 //SIN LÍMITES: No hay número máximo de movimientos.
 Console.WriteLine("Elige el modo de Juego: \n Clásico: 1. \n Sin límites: 2");
 int juego = (int)(Console.ReadKey(true)).KeyChar - '0';
 genera(tab);
 //BUCLE PRINCIPAL
 //Comparación de modos de juego.
 if (juego == 1)
 {
 //Caso base del que partimos.
 cont = 30;
 Console.Clear();
 dibuja(tab, cont, juego);
 //Mientras no sea final de partida, hacemos este bucle pidiéndole un color al usuario,
 //llamando al algoritmo de propagación, modificando el contador y pintando de nuevo el tablero.
 while (cont > 0 && !finalPartida(tab))
 {
 Color nuevo = leeColor();
 expande(tab, nuevo);
 Console.Clear();
 cont--;
 dibuja(tab, cont, juego);
 }
 if (finalPartida(tab))
 Console.WriteLine("\n \n Enhorabuena, ¡Has ganado!");
 else Console.WriteLine("\n \n ¡Mala suerte! Inténtalo de nuevo");
 }
 else if (juego == 2)
 {
 Console.Clear();
 dibuja(tab, cont, juego);
 while (!finalPartida(tab))
 {
 Color nuevo = leeColor();
 expande(tab, nuevo);
 Console.Clear();
 cont++;
 dibuja(tab, cont, juego);
}
 Console.WriteLine("\n \n Enhorabuena, ¡Has ganado!"); 
 }
 else Console.WriteLine("Modo de juego no válido");
 Console.ReadKey();
 }
 }
}
Códigos/Recorridos y busquedas en arrays unidimensionales. Polinomios.csusing System;
namespace polinomios
{
	class MainClass
	{
		const int N = 100;
		struct Monomio {
			public double coef;
			public int exp;
		}
		struct Polinomio {
			public Monomio [] mon;
			public int tam;
		}
		static void leeMonomio(out Monomio m){
			Console.Write ("Coeficiente: ");
			m.coef = double.Parse (Console.ReadLine ());
			Console.Write ("Exponente: ");
			m.exp = int.Parse (Console.ReadLine ());
		}
		static void leePolinomio(out Polinomio p){
			p.mon = new Monomio[N];
			p.tam = 0;
			Console.Write ("Número de monomios: ");
			int n = int.Parse (Console.ReadLine ());
					
			Console.WriteLine ("Introduce monomios");
			for (int i=0; i<n; i++) {
				Monomio m;
				leeMonomio (out m);
				inserta (m, ref p);
			}
		}
		static void escribePolinomio(Polinomio p){
			for (int i = 0; i < p.tam; i++)
				Console.Write (" + " + p.mon [i].coef + "x^" + p.mon [i].exp);
			}
		static void inserta(Monomio m, ref Polinomio p){
			if (m.coef != 0) {
				int i = 0;
				// busqueda de mon del mismo grado
				while (i<p.tam && m.exp != p.mon[i].exp)
					i++;
				if (i < p.tam) { // monomio encontrado
					double c = p.mon [i].coef + m.coef;
					if (c == 0) { // suma nula....
						p.mon [i] = p.mon [p.tam - 1];
						p.tam--;
					} else
						p.mon [i].coef = c;
				} else { // añadimos m al final
					if (p.tam==N) {
						Console.WriteLine ("error: polinomio lleno");
					}
					else {
						p.mon [p.tam] = m;
						p.tam++;
					}
				}
			}
		}
		static Polinomio suma(Polinomio p1, Polinomio p2){
			Polinomio p3;
			p3.mon = new Monomio[N];
			p3.tam = 0;
			// insertamos uno a uno los monimios de ambos polinomios
			// el método inserta hará las sumas correspondientes de los monomios del mismo grado
			for (int i=0; i<p1.tam; i++)
				inserta (p1.mon [i], ref p3);
			for (int i=0; i<p2.tam; i++)
				inserta (p2.mon [i], ref p3);
			return p3;
		}
		static double evalua(Polinomio p, double v){
			double ac = 0;
			// recorrido
			for (int i=0; i<p.tam; i++)
				ac += p.mon [i].coef * Math.Pow (v,p.mon [i].exp);
			return ac;
		}
		static int grado(Polinomio p){
			int gr = 0;
			// recorrido
			for (int i = 0; i < p.tam; i++)
				if (p.mon [i].exp > gr)
					gr = p.mon [i].exp;
			return gr;
		}
		static double coef(Polinomio p, int exp){
			double c = 0;
			// búsqueda
			int i=0;
			// mientras no llegemos al al final de la estructura
			// y no encontremos el monomio buscado, avanzar
			while (i < p.tam && p.mon [i].exp != exp)
				i++;
			// notese que no hay problema en utilizar exp como parámetro y nombre de campo
			// si no hemos llegado al final, hemos parado pq 
			// hemos encontrado el monomio
			if (i < p.tam)
				c = p.mon [i].coef;
			return c;
		}
				
		static Polinomio multiplica(Polinomio p1, Polinomio p2){
			Polinomio p3;
			p3.mon = new Monomio[N];
			p3.tam = 0;
			// recorrido
			for (int i = 0; i < p1.tam; i++) {
				// recorrido
				for (int j = 0; j < p2.tam; j++) {
					Monomio m;
					m.coef = p1.mon [i].coef * p2.mon [j].coef;
					m.exp = p1.mon [i].exp + p2.mon [j].exp;
					inserta (m, ref p3);
				}
			}
			return p3;
		}
		public static void Main ()
		{
			Polinomio p1, p2;
			//leePolinomio (out p1);
			p1.mon = new Monomio[N];
			p1.tam=4;
			for (int i = 0; i < 4; i++) {
				p1.mon [i].coef = i;
				p1.mon [i].exp = 2 * i;
			}
			escribePolinomio (p1);
			p2.mon = new Monomio[N];
			p2.tam=2;
			for (int i = 0; i < 2; i++) {
				p2.mon [i].coef = -i+2;
				p2.mon [i].exp = i;
			}
			Console.WriteLine ();
			escribePolinomio (p2);
			Polinomio p3 = multiplica (p1, p2);
			Console.WriteLine ();
			escribePolinomio (p3);
			Console.WriteLine ();
			//Console.WriteLine ("Eval: "+ evalua (p1, 1));
		}
	}
}
Códigos/Recorridos y búsquedas en arrays bidimensionales. Matrices.csusing System;
namespace arrays2
{
	class MainClass
	{
		// pasando las el tamaño en cada dimension
		static void escribeMat(int [,] v, int fils, int cols){
			// recorrido de un vector bidimensional -> dos for anidados
			for (int i = 0; i < fils; i++) {
				for (int j = 0; j < cols; j++) {
					Console.Write ("{0,3}", v [i, j]);
				}
				// al final de cada fila, salto de línea
				Console.WriteLine ();
			}
		}
					
		// sin pasar tamaño de cada dimension
		static void escribeMat2(int [,] v){
			// recorrido de un vector bidimensional -> dos for anidados
			for (int i = 0; i < v.GetUpperBound(0)+1; i++) {
				for (int j = 0; j < v.GetUpperBound(1)+1; j++) {
					Console.Write ("{0,3}", v [i, j]);
				}
				// al final de cada fila, salto de línea
				Console.WriteLine ();
			}
		}
		static void sumaMat(int [,] m1, int [,] m2, int [,] m3){	
			int fils = m1.GetUpperBound(0) + 1, cols = m1.GetUpperBound(1) + 1;
			for (int i=0; i<fils; i++)
				for (int j=0; j<cols; j++)
					m3[i,j] = m1[i,j] + m2[i,j];			
		}
		static void sumaMat(int [,] m1, int [,] m2, out int [,] m3){							
			// matriz de salida, inicialmente null
			m3 = null;
			// comprobamos tamañaos
			if (m1.GetUpperBound (0) != m2.GetUpperBound (0) ||
			 m1.GetUpperBound (1) != m2.GetUpperBound (1))
				Console.WriteLine ("Error: matrices no coinciden en tamaño\n");
			else {
				int fils = m1.GetUpperBound (0) + 1, cols = m1.GetUpperBound (1) + 1;
				// creamos la nueva matriz
				m3 = new int[fils, cols];
				// recorrido simultáneo de dos vectores bidimensionales -> dos for anidados
				for (int i = 0; i < fils; i++)
					for (int j = 0; j < cols; j++)
						m3 [i, j] = m1 [i, j] + m2 [i, j];			
			}
		}
		static void buscaNeg(int [,] v, out int x, out int y){
			int i = 0, j = 0;
			int fils = v.GetUpperBound (0) + 1,
				cols = v.GetUpperBound (1) + 1;	
			bool enc = false; // variable centinela "encontrado"
			// busqueda en un vector bidimensional -> dos while anidados
			// barrido por filas
			i = 0;
			while (i<fils && !enc) { // control de rango y 
				// barrido por columnas
				// para cada fila inicializamos columna a 0
				j = 0;
				while (j<cols && !enc) {
					if (v[i,j]<0) enc = true;
					else j++;
				}
				if (!enc) i++;
			}
			// encontrado, devolvemos coordenadas
			if (enc) { 
				x = i;
				y = j;
			// si no, devolvemos coordenadas negativas (no válidas)
			} else x = y = -1;
		}
		static int[,] multiplica(int [,] m1, int [,] m2){							
			int [,] m3 = null;
			int fils1 = m1.GetUpperBound (0) + 1;
			int cols1 = m1.GetUpperBound (1) + 1;
			int fils2 = m2.GetUpperBound (0) + 1;
			int cols2 = m2.GetUpperBound (1) + 1;
			// num_cols(m1) == num_fils(m2)
			if (cols1 != fils2)
				Console.WriteLine ("Error: matrices no multiplicables\n");
			else {
				m3 = new int[fils1,cols2];
				// para cada fila de m1
				for (int i=0; i<fils1; i++)
					// para cada columna de m2
					for (int j = 0; j < cols2; j++){
						// m3[i,j] = Sum_1^cols1 m1[i,k]*m2[k,j];
						m3[i,j]=0;
						for (int k=0; k<cols1; k++)
							m3[i,j] += m1[i,k]*m2[k,j];
					}
			}
			return m3;
		}
					
						
		public static void Main (string[] args)
		{
			int[,] u = {{1,2,3},{4,5,6} }; //new int[2,3];
			int[,] v = {{1,2},{2,1},{1,2}};// new int[3,2];
			int[,] r = multiplica (u, v);
			escribeMat2 (r);
		
		}
	}
}
Códigos/Snake.cs//PRÁCTICA 4 - SNAKE
//Alejandro Ortega Álvarez
//José María Monreal González
//Roberto Alcázar Morales
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Snake
{
 enum Dir
 {
 Norte, Sur, Este, Oeste, Null
 }
 class ListaEnlazada
 {
 class Nodo
 {
 public int x, y;
 public Nodo sig; // enlace al siguiente nodo
 // constructor 
 public Nodo(int i, int j)
{ x = i; y = j; }
 }
 // atributos de la lista enlazada: referencia al primero y al último		
 Nodo pri, ult, act;
 // constructora de listas
 public ListaEnlazada()
 {
 pri = ult = act = null;
 }
 // obtener primer elto de la lista
 //Sirve para conocer las coordenadas del cuerpo de la serpiente
 public void primero(out int i, out int j)
 {
 if (pri == null) throw new Exception("Error primero: lista vacia");
 i = pri.x; j = pri.y;
 }
 // obtener ultimo elto de la lista
 public void ultimo(out int i, out int j)
 {
 if (ult == null) throw new Exception("Error ultimo: lista vacia");
 i = ult.x; j = ult.y;
 }
 // ver si un elto esta en la lista
 public bool esta(int i, int j)
 {
 // iniciamos con aux al ppio
 Nodo aux = pri;
 // busqueda: avanzazmos con aux mientras no llegemoa al final y no encontremos elto
 while (aux != null && (aux.x != i || aux.y != j)) aux = aux.sig;
 // si no hemos llegado el final, es pq el elto está en la lista
 return (aux != null);
 }
 // insertar elto al ppio de la lista
 public void insertaIni(int x, int y)
 {
 // si la lista es vacia creamos nodo y apuntamos a el pri y ult
 if (pri == null)
 {
 pri = new Nodo(x, y);
 pri.sig = null;
 ult = pri;
 }
 else
 { // si no es vacia creamos nodo y lo enganchamos al ppio
 Nodo aux = new Nodo(x, y);
 aux.sig = pri;
 pri = aux;
 }
 }
 // insertar elto al final de la lista
 public void insertaFin(int x, int y)
 {
 // si es vacia creamos nodo y apuntamos a el ppi y ult
 if (pri == null)
 {
 pri = new Nodo(x, y);
 pri.sig = null;
 ult = pri;
 }
 else
 { // si no, creamos nodo apuntado por ult.sig y enlazamos
 ult.sig = new Nodo(x, y);
 ult = ult.sig;
 ult.sig = null;
 }
 }
 // elimina elto dado de la lista, si esta
 public void eliminaElto(int x, int y)
 {
 // lista vacia
 if (pri == null) throw new Exception("Error eliminaElto: lista vacia");
 else
 {
 // eliminar el primero
 if (x == pri.x && y == pri.y)
 {
 // si solo tiene un elto
 if (pri == ult)
 pri = ult = null;
 // si tiene más de uno
 else
 pri = pri.sig;
 }
 // eliminar otro distinto al primero
 else
 {
 // busqueda. aux al ppio
 Nodo aux = pri;
 // recorremos lista buscando el ANTERIOR al que hay que eliminar (para poder luego enlazar)
 while (aux.sig != null && (x != aux.sig.x || y != aux.sig.y))
 aux = aux.sig;
 // si lo encontramos
 if (aux.sig != null)
 {
 // si es el ultimo cambiamos referencia al ultimo
 if (aux.sig == ult)
 ult = aux;
 // puenteamos
 aux.sig = aux.sig.sig;
 }
 }
 }
 }
 // elimina primer elto de la lista
 public void eliminaIni()
 {
 if (pri == null) throw new Exception("Error eliminaIni: lista vacia");
 if (pri == ult) pri = ult = null;
 else pri = pri.sig;
 }
 // inicizlización del iterador. Lo colocamos al ppio
 public void iniciaRecorrido()
 {
 act = pri;
 }
 public bool dame_actual_y_avanza(out int x, out int y)
 {
 x = y = 0;
 // si estamos al final, ya no hay actual y devolvemos false
 if (act == null)
 return false;
 else
 { // si no, info del nodo, avanzamos act y devolvemos true
 x = act.x;
 y = act.y;
 act = act.sig;
 return true;
 }
 }
 /* auxiliar solo para depuración
 public void verLista(){
 Console.Write ("Lista: ");
 Nodo aux = pri;
 while (aux != null) {
 Console.Write ("(" + aux.x + "," + aux.y + ") ");
 aux = aux.sig;
 }
 Console.Write ("\n\n");
 }
 */
 }
 //CLASE ESTADO
 class Estado
 {
 int fils, cols;
 ListaEnlazada Serp = new ListaEnlazada();
 ListaEnlazada Frutas = new ListaEnlazada();
 Random rnd = new Random();
 public int dirx, diry;
 //Se crean las listas de la serp y las frutas y se inicializa la dirección a ESTE
 public Estado(int ancho, int alto)
 {
 fils = alto;
 cols = ancho;
 Serp = new ListaEnlazada();
 Serp.insertaIni(alto / 2, ancho / 2);
 Frutas = new ListaEnlazada();
 dirx = 1;
 diry = 0;
 }
 //Determina si hay colisión en las posicion x,y
 public bool colision(int x, int y)
 {
 if (x == 0 || x > fils || y == 0 || y > cols || Serp.esta(x, y)) //choca con los bordes
 return true;
 else
 return false;
 }
 //Hace avanzar una unidad a la serpiente y, si hay fruta, crece una unidad
 public void avanza()
 {
 int x, y;
 Serp.ultimo(out x, out y);
 x += dirx;
 y += diry;
 if (!colision(x, y))
 {
 Serp.insertaFin(x, y);
 if (Frutas.esta(x, y))
 Frutas.eliminaElto(x, y);
 else
 Serp.eliminaIni(); 
 }
 else throw new Exception("Choque detectado");
 }
 //Modifica la dirección de la serpiente
 void cambiaDir(Dir dir)
 {
 switch (dir)
 {
 case Dir.Oeste:
 dirx = -1;
 diry = 0;
 break;
 case Dir.Norte:
 dirx = 0;
 diry = -1;
 break;
 case Dir.Este:
 dirx = 1;
 diry = 0;
 break;
 case Dir.Sur:
 dirx = 0;
 diry = 1;
 break;
 case Dir.Null:
 break;
 }
 }
 //Coloca en el tablero frutas aleatorias
 public void ponFruta()
 {
 {
 int x, y;
 do
 {
 x = rnd.Next(1, fils);
 y = rnd.Next(1, cols);
 }
 while (Serp.esta(x, y) || Frutas.esta(x, y));
 Frutas.insertaIni(x, y);
 }
 }
 //Método útil para llamar en el Dibuja()
 public void pinta(int x, int y, ConsoleColor Color)
 {
 Console.BackgroundColor = Color;
 Console.SetCursorPosition(2 * x, y); //Dibujado en cuadrados
 Console.WriteLine("
");
 }
 //Dibuja los bordes, la serpiente y las frutas
 void dibuja()
 {
 Console.BackgroundColor = ConsoleColor.Black;
 Console.Clear();
 Console.SetCursorPosition(0, 0);
 //Para los bordes del tablero (Rojo)
 for (int i = 0; i <= fils + 1; i++) //recorre el tablero para buscar los bordes
 {
 for (int j = 0; j <= cols + 1; j++)
 {
 if (i == 0 || j == 0 || i == fils + 1 || j == cols + 1)//hace que solo pinte los bordes
 {
 pinta(i, j, ConsoleColor.Red);
 }
 }
 }
 //Para la serpiente
 int x, y;
 Serp.iniciaRecorrido();
 while (Serp.dame_actual_y_avanza(out x, out y))
 pinta(x, y, ConsoleColor.Green);
 //Colocamos la cabeza de la serpiente
 Serp.ultimo(out x, out y);
 Console.SetCursorPosition(2 * x, y);
 Console.Write("<>");
 //Para las frutas
 Frutas.iniciaRecorrido();
 while (Frutas.dame_actual_y_avanza(out x, out y))
 pinta(x, y, ConsoleColor.Cyan);
 }
 class Program
 {
 static Dir leeEntrada()
 {
 Dir d = Dir.Null;
 if (Console.KeyAvailable)
 {
 string tecla = Console.ReadKey().Key.ToString();
 switch (tecla)
 {
 case "LeftArrow":
 d = Dir.Oeste;
 break;
 case "UpArrow":
 d = Dir.Norte;
 break;
 case "RightArrow":
 d = Dir.Este;
 break;
 case "DownArrow":
 d = Dir.Sur;
 break;
 }
 while (Console.KeyAvailable)
 (Console.ReadKey(false)).KeyChar.ToString();
 }
 return d;
 }
 //MÉTODO PRINCIPAL DEL JUEGO
 public static void Main(string[] args)
 {
 int alto = 20;
 int ancho = 20;
 int cont = 0;
 bool partida = true;
 Estado estado = new Estado(alto, ancho); //Primero creamos un estado con un ancho y largo
 estado.ponFruta(); //dibuja la primera fruta
 estado.dibuja(); //dibuja el tablero
 while (partida)
 {
 if (cont == 25)
 {
 estado.ponFruta();
 cont = 0;
 }
 Dir d = leeEntrada();
 estado.cambiaDir(d);
 try 
 {
 estado.avanza();
 estado.dibuja();
 cont++;
 System.Threading.Thread.Sleep(400);
 }
 catch {
 Console.SetCursorPosition(0,estado.cols +5);
 Console.BackgroundColor = ConsoleColor.Black;
 Console.WriteLine("¡Te has chocado!");
 partida = false;
 }
 }
 Console.ReadKey();
 }
 }
 }
}
Códigos/Sopa.csusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace Sopita
{
 struct Par
 { // representa posiciones y direcciones
 public int x, y;
 }
 struct Sopa
 { // sopa de letras junto con sus dimensiones
 public int alto, ancho; // dimensiones
 public string[] matriz; // array de strings
 }
 class Program
 {
 static Par[] dirs()
 {
 Par [] direcc = new Par [8];
 int k = 0;
 for (int i = -1; i <= 1; i++)
 {
 for (int j = -1; j <= 1; j++)
 {
 if (i != 0 && j != 0)
 {
 direcc[k].x = i;
 direcc[k].y = j;
 k++;
 }
 }
 }
 return direcc;
 }
 static string DameLetras(Sopa s, Par pos, Par dir, int n)
 {
 string pal = null;
 int i=0;
 while ((pos.x>0 && pos.x<s.ancho && pos.y>0 && pos.y<s.alto ) && i < n) 
 {
 pal += s.matriz[pos.x][pos.y];
 pos.x += dir.x;
 pos.y += dir.y;
 i++;
 }
 if (i == n)
 return pal;
 else
 return null;
 }
 static bool buscaPos(Sopa s, string pal, out Par pos, Par dir)
 {
 Par posicion = new Par();
 bool encontrado = false;
 int i=0;
 int j=0;
 while (!encontrado && i < s.ancho)
 {
 while (!encontrado && j < s.alto)
 {
 posicion.x = i;
 posicion.y = j;
 if (string.Compare(pal, DameLetras(s, posicion, dir, pal.Length)) == 0)
 encontrado = true;
 
 j++; 
 }
 i++;
 }
 pos = posicion;
 return encontrado;
 }
 static bool buscaPal(Sopa s, string pal, out Par pos, out Par dir)
 {
 Par posicion = new Par();
 Par [] direccion = dirs ();
 bool encontrado = false;
 int k = 0;
 while (!encontrado && k < direccion.Length)
 {
 if (buscaPos(s, pal, out posicion, direccion[k]))
 encontrado = true;
 else
 k++;
 }
 if (encontrado)
 dir = direccion[k]; 
 else
 dir = direccion [0];
 pos = posicion;
 return encontrado;
 }
 static void resuelve(Sopa s, string[] pals)
 {
 int k = 0;
 Par pos = new Par();
 Par dir = new Par();
 while (k < pals.Length)
 {
 if (buscaPal(s, pals[k], out pos, out dir))
 Console.WriteLine("Encontrada " + pals[k] + "en Posicion " + pos.x + "," + pos.y + "dirección" + dir.x + "," + dir.y);
 else
 Console.WriteLine("No encontrada " + pals[k]);
 
 k++;
 }
 }
 static void leeSopa(Sopa s, string[] pals)
 {
 StreamReader entrada = new StreamReader("entrada.txt");
 s.alto = int.Parse(entrada.ReadLine());
 s.ancho = int.Parse(entrada.ReadLine());
 for (int i = 0; i < s.alto; i++)
 s.matriz[i] = entrada.ReadLine();
 int nums= pals.Length; 
 nums = int.Parse(entrada.ReadLine());
for (int j = 0; j < pals.Length; j++)
 {
 pals[j] = entrada.ReadLine();
 }
 entrada.Close();
 }
 static void Main(string[] args)
 {
 Sopa s;
 s.alto = 6;
 s.ancho = 9;
 s.matriz = new string[] { // sopa de letras del ejemplo
 "ABCDBARCO" , "EKLMNOPQR" , "HTAVIONOR" , "CGRTUITXB" , "OROHFOVAZ" , "CMPPMEVAN" };
 string[] pals = { "COCHE", "AVION", "BARCO", "MOTO", "PATINES" };
 resuelve(s, pals);
 Console.ReadKey();
 }
 }
}
Códigos/ZyanDrenchFINAL.rar 
ZDFINAL/.vs/ZDFINAL/v14/.suo
ZDFINAL/ZDFINAL/App.config 
 
 
 
ZDFINAL/ZDFINAL/bin/Debug/ZDFINAL.exe
ZDFINAL/ZDFINAL/bin/Debug/ZDFINAL.exe.config 
 
 
 
ZDFINAL/ZDFINAL/bin/Debug/ZDFINAL.pdb
ZDFINAL/ZDFINAL/bin/Debug/ZDFINAL.vshost.exe
ZDFINAL/ZDFINAL/bin/Debug/ZDFINAL.vshost.exe.config 
 
 
 
ZDFINAL/ZDFINAL/bin/Debug/ZDFINAL.vshost.exe.manifest 
 
 
 
 
 
 
 
 
ZDFINAL/ZDFINAL/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache
ZDFINAL/ZDFINAL/obj/Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs
ZDFINAL/ZDFINAL/obj/Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs
ZDFINAL/ZDFINAL/obj/Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs
ZDFINAL/ZDFINAL/obj/Debug/ZDFINAL.csproj.FileListAbsolute.txtC:\Users\JCoffee\Desktop\ZDFINAL\ZDFINAL\bin\Debug\ZDFINAL.exe.config
C:\Users\JCoffee\Desktop\ZDFINAL\ZDFINAL\bin\Debug\ZDFINAL.exe
C:\Users\JCoffee\Desktop\ZDFINAL\ZDFINAL\bin\Debug\ZDFINAL.pdb
C:\Users\JCoffee\Desktop\ZDFINAL\ZDFINAL\obj\Debug\ZDFINAL.csprojResolveAssemblyReference.cache
C:\Users\JCoffee\Desktop\ZDFINAL\ZDFINAL\obj\Debug\ZDFINAL.exe
C:\Users\JCoffee\Desktop\ZDFINAL\ZDFINAL\obj\Debug\ZDFINAL.pdb
ZDFINAL/ZDFINAL/obj/Debug/ZDFINAL.csprojResolveAssemblyReference.cache
ZDFINAL/ZDFINAL/obj/Debug/ZDFINAL.exe
ZDFINAL/ZDFINAL/obj/Debug/ZDFINAL.pdb
ZDFINAL/ZDFINAL/Program.cs/// PRÁCTICA 3 - INTEGRANTES:
/// José María Monreal González
/// Alejandro Ortega Álvarez
/// Roberto Alcázar Morales
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZDFINAL
{
 class Program
 {
 //CONSTANTES
 const int ANCHO = 15, ALTO = 15;
 static Random rnd = new Random();
 public enum Color { rojo, cyan, verde, amarillo, azul, magenta };
 struct Posicion
 {
 public int x, y;
 }
 //Nuestro struct Visitados con el array posVis de tipo Posicion y los enteros pend y fin.
 struct Visitados
 {
 public Posicion[] posVis; 
 public int pend, fin;
 }
 //Método que genera de manera aleatoria utilizando el random ya declarado un color para cada casilla del tablero.
 public static void genera(Color[,] tab)
 {
 for (int i = 0; i < ANCHO; i++)
 {
 for (int j = 0; j < ALTO; j++)
 {
 tab[i, j] = (Color)rnd.Next(0, 6);
 }
 }
 }
 //Método encargado de pintar en pantalla el tablero y el panel de selección de colores, además del número de jugadas.
 public static void dibuja(Color[,] tab, int cont, int juego)
 {
 for (int i = 0; i < ALTO; i++)
 {
 for (int j = 0; j < ANCHO; j++)
 {
 switch (tab[i, j])
 {
 case Color.rojo:
 Console.BackgroundColor = ConsoleColor.Red;
 break;
 case Color.cyan:
 Console.BackgroundColor = ConsoleColor.Cyan;
 break;
 case Color.verde:
 Console.BackgroundColor = ConsoleColor.Green;
 break;
 case Color.amarillo:
 Console.BackgroundColor = ConsoleColor.Yellow;
 break;
 case Color.azul:
 Console.BackgroundColor = ConsoleColor.Blue;
 break;
 case Color.magenta:
 Console.BackgroundColor = ConsoleColor.Magenta;
 break;
 }
 Console.Write(" ");
 }
 Console.WriteLine();
 }
 Console.Write("\n\n\n");
 //Dibujado del panel de control
 Console.BackgroundColor = ConsoleColor.Red;
 Console.Write(" 1 ");
 Console.BackgroundColor = ConsoleColor.Cyan;
 Console.Write(" 2 ");
 Console.BackgroundColor = ConsoleColor.Green;
 Console.Write(" 3 ");
 Console.WriteLine();
 Console.BackgroundColor = ConsoleColor.Yellow;
 Console.Write(" 4 ");
 Console.BackgroundColor = ConsoleColor.Blue;
 Console.Write(" 5 ");
 Console.BackgroundColor = ConsoleColor.Magenta;
 Console.Write(" 6 ");
 Console.WriteLine();
 
 //Al terminar restablecemos de nuevo el color por defecto de la consola (negro).
 Console.BackgroundColor = ConsoleColor.Black;
 //Escribimos por pantalla las jugadas dependiendo del modo de juego en el que nos encontremos.
 if (juego == 1)
 Console.Write("\n Jugadas Restantes: " + cont);
 else Console.Write("\n Jugadas Totales: " + cont);
 }
 //Método que comprueba si la posición dada (pos) se encuentra dentro del array posVis.
 static bool estaVisitado(Visitados vis, Posicion pos)
 {
 int i = 0;
 
 while ((i < vis.fin) && (pos.x != vis.posVis[i].x || pos.y != vis.posVis[i].y))
 i++;
 return (i != vis.fin);
 }
 //Añade las posiciones adyacentes de la posición dada en el caso de que no estén visitadas anteriormente.
 static void añadeVecinos(ref Visitados vis, Posicion pos)
 {
 Posicion aux = pos;
 aux.x = pos.x + 1;
 if (aux.x < ANCHO && !estaVisitado(vis, aux))
 {
 vis.posVis[vis.fin] = aux; 
 vis.fin++;
 }
 aux.x = pos.x - 1;
 if (aux.x >= 0 && !estaVisitado(vis, aux))
 {
 vis.posVis[vis.fin] = aux;
 vis.fin++;
 }
 //Reiniciamos la posición x a su valor inicial.
 aux.x = pos.x;
 aux.y = pos.y + 1;
 if (aux.y < ALTO && !estaVisitado(vis, aux))
 {
 vis.posVis[vis.fin] = aux;
 vis.fin++;
 }
 aux.y = pos.y - 1;
 if (aux.y >= 0 && !estaVisitado(vis, aux))
 {
 vis.posVis[vis.fin] = aux;
 vis.fin++;
 }
 }
 //Inicializa pend y fin de Visitados, además de declarar el array posVis. 
 //Este método contiene el algoritmode propagación del color que recorre el array posVis
 //y va coloreando las posiciones del tablero que correspondan.
 static void expande(Color[,] tab, Color nuevo)
 {
 
 Visitados vis;
 vis.posVis = new Posicion[ALTO * ANCHO];
 Posicion inicial;
 inicial.x = 0;
 inicial.y = 0;
 vis.posVis[0] = inicial;
 vis.pend
= 0;
 vis.fin = 1;
 //Guardamos siempre en old el color antiguo de la casilla de referencia para la posterior comparación.
 Color old = tab[0, 0];
 //Mientras queden posiciones en el array posVis el algoritmo de propagación no termina.
 //El algoritmo hace una comprobación de la casilla a la que señala vis.pend y comprueba que no sea del color
 //que el jugador ha pulsado en el momento de la ejecución (nuevo) y que además sea el antiguo. 
 //Si esas dos condiciones se cumplen, "pintará" la casilla del nuevo color y añadirá sus casillas adyacentes al array posVis.
 while (vis.pend < vis.fin)
 {
 if (nuevo != tab[vis.posVis[vis.pend].x, vis.posVis[vis.pend].y] &&
 old == tab[vis.posVis[vis.pend].x, vis.posVis[vis.pend].y]) 
 {
 tab[vis.posVis[vis.pend].x, vis.posVis[vis.pend].y] = nuevo;
 añadeVecinos(ref vis, vis.posVis[vis.pend]);
 }
 vis.pend++;
 }
 }
 //Método encargado de devolver true/false si se ha terminado o no la partida.
 static bool finalPartida(Color[,] tab)
 {
 Color colorFinal = tab[0, 0];
 
 int i = 0, j = 0, cont = 0;
 
 while (i < ANCHO && colorFinal == tab[i, j])
 {
 while (j < ALTO && colorFinal == tab[i, j])
 {
 j++;
 cont++;
 }
 j = 0;
 i++;
 }
 return (cont == ALTO * ANCHO);
 }
 //Lee de teclado un número del 1-6 y lo convierte al color correspondiente (casting).
 static Color leeColor()
 {
 return (Color)(Console.ReadKey(true)).KeyChar - '0' - 1;
 }
 //MÉTODO PRINCIPAL
 static void Main(string[] args)
 {
 Color[,] tab = new Color[ANCHO, ALTO];
 int cont = 0;
 //Modos de juego:
 //CLÁSICO: Tienes un máximo de 30 movimientos para terminar la partida
 //SIN LÍMITES: No hay número máximo de movimientos.
 Console.WriteLine("Elige el modo de Juego: \n Clásico: 1. \n Sin límites: 2");
 int juego = (int)(Console.ReadKey(true)).KeyChar - '0';
 genera(tab);
 //BUCLE PRINCIPAL
 //Comparación de modos de juego.
 if (juego == 1)
 {
 //Caso base del que partimos.
 cont = 30;
 Console.Clear();
 dibuja(tab, cont, juego);
 //Mientras no sea final de partida, hacemos este bucle pidiéndole un color al usuario,
 //llamando al algoritmo de propagación, modificando el contador y pintando de nuevo el tablero.
 while (cont > 0 && !finalPartida(tab))
 {
 Color nuevo = leeColor();
 expande(tab, nuevo);
 Console.Clear();
 cont--;
 dibuja(tab, cont, juego);
 }
 if (finalPartida(tab))
 Console.WriteLine("\n \n Enhorabuena, ¡Has ganado!");
 else Console.WriteLine("\n \n ¡Mala suerte! Inténtalo de nuevo");
 }
 else if (juego == 2)
 {
 Console.Clear();
 dibuja(tab, cont, juego);
 while (!finalPartida(tab))
 {
 Color nuevo = leeColor();
 expande(tab, nuevo);
 Console.Clear();
 cont++;
 dibuja(tab, cont, juego);
 
 }
 Console.WriteLine("\n \n Enhorabuena, ¡Has ganado!"); 
 }
 else Console.WriteLine("Modo de juego no válido");
 Console.ReadKey();
 }
 }
}
ZDFINAL/ZDFINAL/Properties/AssemblyInfo.csusing System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ZDFINAL")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ZDFINAL")]
[assembly: AssemblyCopyright("Copyright © 2016")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components. If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("36a14081-d8fe-4baf-83f2-6e84d55e5994")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version 
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
ZDFINAL/ZDFINAL/ZDFINAL.csproj 
 
 
 Debug
 AnyCPU
 {36A14081-D8FE-4BAF-83F2-6E84D55E5994}
 Exe
 Properties
 ZDFINAL
 ZDFINAL
 v4.5.2
 512
 true
 
 
 AnyCPU
 true
 full
 false
 bin\Debug\
 DEBUG;TRACE
 prompt
 4
 
 
 AnyCPU
 pdbonly
 true
 bin\Release\
 TRACE
 prompt
 4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ZDFINAL/ZDFINAL.sln
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 14
VisualStudioVersion = 14.0.23107.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZDFINAL", "ZDFINAL\ZDFINAL.csproj", "{36A14081-D8FE-4BAF-83F2-6E84D55E5994}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{36A14081-D8FE-4BAF-83F2-6E84D55E5994}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{36A14081-D8FE-4BAF-83F2-6E84D55E5994}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{36A14081-D8FE-4BAF-83F2-6E84D55E5994}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{36A14081-D8FE-4BAF-83F2-6E84D55E5994}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal