Aventuras y desventuras de un IT
Recién sacadito del horno.
1º Ejercicio:
Obtener las trazas para las siguientes palabras en este autómata :
Las palabras de las que se deben obtener las trazas son:
2º Ejercicio: Crea un AFND que acepte los números binarios en los que la tercera cifra por la derecha sea diferenta a la segunda por la izquierda.
Resuelto aquí con muchas mas soluciones de otros modelos de examen.
Que tengáis mucha suerte.
http://www.melasuda.org/blog/2010/04/09/pequeno-proyecto-en-c-gestion-de-proyecto-tecnologico/
Enjoy
EJERCICIOS
Inicialmente debes construir un nuevo proyecto (practica4). Una vez creado, copia en el directorio de trabajo los ficheros examinar.c, examinar.h y la librería creada en la práctica anterior glig.c con su fichero prototipo glig.h. Añádelos al proyecto (por supuesto, acuérdate de añadir también las librerías glu32.lib, glut.lib y opengl32.lib).
1. Para la realización de esta práctica vas a necesitar una nueva primitiva que dibuje un cono. Añádela a tu librería glig.c.
void igWireCone (int pu, int pv); /* s1= 2.0, s2= 1.0, uMax= 1.0, vMax= 0.5 */
2. Utiliza las primitivas de la librería glig.c, para construir un abeto como el de la figura, sin utilizar las funciones glPushMatrix() y glPopMatrix(). Para ello crea una display list como en el ejemplo e introduce en su definición el código necesario para dibujar el abeto:
void CreaAbeto (void)
{
abeto = glGenLists (1);
if (abeto != 0) /* Cero no es un identificador valido para una display list */
{
glNewList (abeto, GL_COMPILE);
/* Código para dibujar el abeto */
glEndList ();
}
}
Los pasos a seguir para dibujar el abeto son:
Desde la función principal (main) debes llamar una única vez a CreaAbeto(). Para dibujar el abeto como una display list, llama desde la función Dibuja() a:
glCallList (abeto);
3. Construye el mismo abeto pero mediante el uso de las funciones glPushMatrix() y glPopMatrix(). Es decir, haz que cada primitiva tenga sus transformaciones propias y que estas no afecten a las otras primitivas. Declara una nueva display list (abetoPush) y crea la display list para dibujar el abeto con las funciones glPush() y glPop() y llámala CreaAbetoPush().Comprueba que los dos abetos son iguales dibujando uno sobre otro con distintos colores.
4. Utilizando las primitivas de la librería glig.c, construye una display list para una escalera de caracol (escalera). Introduce el código en la función CreaEscalera(). Los pasos son los siguientes:
5. Realiza la construcción de la figura (lo más parecida posible) de acuerdo con los siguientes pasos:
examinar.c
001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 | /*************************************************************************//* *//* examinar.c *//* Rev. 2.0 01/01/2002 AUTORES: O. Belmonte, M. Chover, J. Ribelles *//* *//*************************************************************************//***************** INCLUDES DE LAS LIBRERIAS NECESARIAS ******************/#include <GL/glut.h>#include <stdio.h>#include <stdlib.h>#include "examinar.h"#include "glig.h"/******************************************************************************************//* Establece el area visible y el tipo de proyeccion *//* Parametros: int ancho --> Ancho del area visible *//* int alto --> Alto del area visible *//* Salida: Ninguna *//******************************************************************************************/void TamanyoVentana (GLsizei ancho, GLsizei alto){ /* Definicion del viewport */ glViewport(0, 0, ancho, alto); /* Definicion de la vista */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-2.0, 2.0, -2.0*(GLfloat)alto/(GLfloat)ancho, 2.0*(GLdouble)alto/(GLfloat)ancho, -2.0, 2.0);}/******************************************************************************************//* Abre una ventana OpenGL *//* Parametros: int numeroArgumentos --> El numero de argumentos en la llamada al programa *//* char ** listaArgumentos --> Vector de cadenas con cada argumento *//* Salida: Ninguna *//******************************************************************************************/void AbreVentana (int numeroArgumentos, char ** listaArgumentos){ glutInit(&numeroArgumentos, listaArgumentos); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (VentanaAncho, VentanaAlto); glutInitWindowPosition (VentanaX, VentanaY); glutCreateWindow (listaArgumentos[0]); glutDisplayFunc (Dibuja); glutReshapeFunc (TamanyoVentana); glClearColor (0.0f, 0.0f, 0.0f, 0.0f); /* Establece el color de borrado */ glClear (GL_COLOR_BUFFER_BIT); /* Borra el buffer de color */ glColor3f (1.0f, 1.0f, 1.0f); /* Establece el color de dibujo */}/******************************************************************************************//* Define las acciones tras una pulsacion del teclado *//* Parametros: unsigned char key --> Codigo de la tecla pulsada *//* int x --> Coordenada x del cursor en el momento de pulsar la tecla *//* int y --> Coordenada y del cursor en el momento de pulsar la tecla *//* Salida: Ninguna *//******************************************************************************************/void Teclado (unsigned char tecla, int x, int y){ switch (tecla) { case 27 : /* Codigo de la tecla de Escape */ exit(0); break; }}/******************************************************************************************//* Define las acciones tras una pulsacion del teclado ampliado *//* Parametros: unsigned char key --> Codigo de la tecla pulsada *//* int x --> Coordenada x del cursor en el momento de pulsar la tecla *//* int y --> Coordenada y del cursor en el momento de pulsar la tecla *//* Salida: Ninguna *//******************************************************************************************/void TecladoAmpliado (int tecla, int x, int y){ switch (tecla) { case GLUT_KEY_UP : /* Pulsacion cursor arriba del teclado ampliado */ beta = beta + 15.0; if (beta > 360.0) beta = beta - 360.0; break; case GLUT_KEY_DOWN : /* Pulsacion cursor abajo del teclado ampliado */ beta = beta - 15.0; if (beta < 0.0) beta = beta + 360.0; break; case GLUT_KEY_RIGHT : /* Pulsacion cursor derecha del teclado ampliado */ alfa = alfa + 15.0; if (alfa > 360.0) alfa = alfa - 360.0; break; case GLUT_KEY_LEFT : /* Pulsacion cursor izquierda del teclado ampliado */ alfa = alfa - 15.0; if (alfa < 0.0) alfa = alfa + 360.0; break; } glutPostRedisplay ();}/* Rutina de definiciÛn de eventos *//******************************************************************************************//* Inicia las funciones de callback *//* Parametros: Ninguno *//* Salida: Ninguna *//******************************************************************************************/void IniciaFuncionesCallback (void){ glutKeyboardFunc (Teclado); glutSpecialFunc (TecladoAmpliado);}/******************************************************************************************//* Funcion de dibujado *//* Parametros: Ninguno *//* Salida: Ninguna *//******************************************************************************************/void Dibuja (void){ glClear (GL_COLOR_BUFFER_BIT); /* Transformacion de la camara */ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glRotated (beta, 1.0,0.0,0.0); glRotated (-alfa, 0.0,1.0,0.0); glCallList (cuadrica); glCallList(abetoPush); glCallList (abeto); glCallList(escalera); glCallList(patio); /* Objetos */ //glutWireTeapot(1.0); //glutWireIcosahedron(); //glutWireTetrahedron(); //glutWireOctahedron(); //glutWireDodecahedron(); //glutWireTorus(0.2,0.9,18,20); //glutWireCone(0.5, 2.0, 14, 14); //glutWireCube(1.0); //glutWireSphere(1, 20,50); //igCreateQuadricObject(50,80,0,0,1.0, 1, 1); //igWireSphere (50, 50); //igWireRulo (200, 200); //igWireDado (60, 60); //igWireSemiSphere (50, 50); // s1 y s2 a 1, uMax= 1, vMax= 0.5 */ //igWireCubo(); glFlush();}void IniciaCuadricas (void){ cuadrica = glGenLists (1); escalera=glGenLists(1); abeto=glGenLists(1); abetoPush=glGenLists(1); patio=glGenLists(1); if (cuadrica != 0) /* Cero no es un identificador valido para una display list */ { //glNewList (cuadrica, GL_COMPILE); //igCreateQuadricObject (20,20,0,0,1.0f, 1.0f, 1.0f); //igWireCubo(); //igWireRulo(20, 20); //igWireCone(10,3); //igWireSphere(30, 30); //glEndList (); printf("Cuadratica\n"); } if (escalera!=0) { //CreaEscalera(); printf("Escalera\n"); } if (abeto!=0) { //CreaAbeto(); printf("Abeto\n"); } if (abetoPush!=0) { glNewList(abetoPush, GL_COMPILE); //CreaAbetoPush(); glEndList(); printf("AbetoPush\n"); } if (patio!=0) { CreaPatio(); printf("patio\n"); }}/******************************************************************************************//* Funcion principal *//* Parametros: int numeroArgumentos --> El numero de argumentos en la llamada al programa *//* char ** listaArgumentos --> Vector de cadenas con cada argumento *//* Salida: Un entero que se devuelve al sistema al acabar la ejecucion del programa *//******************************************************************************************/int main(int numArgumentos, char ** listaArgumentos){ /* CreaciÛn de la ventana de la aplicaciÛn */ AbreVentana (numArgumentos, listaArgumentos); /* Rutinas para el control de eventos */ IniciaFuncionesCallback (); IniciaCuadricas(); /* A la espera de eventos.... */ glutMainLoop(); return (0);} |
glig.c
001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 | /*************************************************************************//* *//* glig.c LIBRERIA DE MODELADO GEOMETRICO *//* *//* Rev. 2.0 01/01/2002 AUTORES: O. Belmonte, M. Chover, J. Ribelles *//* *//*************************************************************************//***************** INCLUDES DE LAS LIBRERIAS NECESARIAS ******************/#include <GL/glut.h>#include <math.h>#include <stdio.h>#include "glig.h"#define PI 3.1415926535897932#define ALFA (0.5-v)*PI#define BETA 2*PI*u/************************* FUNCIONES BASICAS **********************************************//******************************************************************************************//* Devuelve la coordenada x de un punto en R3 a partir de un punto (u,v) *//* de un espacio parametrico en R2 *//* Parametros: float u --> Primera coordenada de un punto en R2 *//* float v --> Segunda coordenada de un punto en R2 *//* float R --> Radio de la esfera envolvente *//* float s1 --> Numero de divisiones en u *//* float s2 --> Numero de divisiones en v *//* Salida: La coordenada x de un punto en R3 *//******************************************************************************************/float xSuperQuadric (float u, float v, float R, float s1, float s2){ float cosalfa, cosbeta, powcosalfa, powcosbeta; cosalfa = (float)cos(ALFA); cosbeta = (float)cos(BETA); if(cosalfa > 0.0) powcosalfa = (float)pow(cosalfa,s1); else powcosalfa =(float) - pow(- cosalfa,s1); if(cosbeta > 0.0) powcosbeta = (float)pow(cosbeta,s2); else powcosbeta = (float) - pow(- cosbeta,s2); return (R*powcosalfa*powcosbeta);}/******************************************************************************************//* Devuelve la coordenada y de un punto en R3 a partir de un punto (u,v) *//* de un espacio parametrico en R2 *//* Parametros: float u --> Primera coordenada de un punto en R2 *//* float v --> Segunda coordenada de un punto en R2 *//* float R --> Radio de la esfera envolvente *//* float s1 --> Numero de divisiones en u *//* float s2 --> Numero de divisiones en v *//* Salida: La coordenada y de un punto en R3 *//******************************************************************************************/float ySuperQuadric (float u, float v, float R, float s1, float s2){ float sinalfa, powsinalfa; sinalfa = (float)sin(ALFA); if(sinalfa > 0.0) powsinalfa = (float)pow(sinalfa,s1); else powsinalfa = (float)- pow(- sinalfa,s1); return (R*powsinalfa);}/******************************************************************************************//* Devuelve la coordenada de un punto en R3 a partir de un punto (u,v) *//* de un espacio parametrico en R2 *//* Parametros: float u --> Primera coordenada de un punto en R2 *//* float v --> Segunda coordenada de un punto en R2 *//* float R --> Radio de la esfera envolvente *//* float s1 --> Numero de divisiones en u *//* float s2 --> Numero de divisiones en v *//* Salida: La coordenada z de un punto en R3 *//******************************************************************************************/float zSuperQuadric(float u, float v, float R, float s1, float s2){ float cosalfa, sinbeta, powcosalfa, powsinbeta; cosalfa = (float)cos(ALFA); sinbeta=(float)sin(BETA); if(cosalfa > 0.0) powcosalfa = (float)pow(cosalfa,s1); else powcosalfa=(float) - pow(- cosalfa,s1); if(sinbeta > 0.0) powsinbeta = (float)pow(sinbeta,s2); else powsinbeta = (float) - pow(- sinbeta,s2); return(R*powcosalfa*powsinbeta);}/********************** RUTINA DE DIBUJO *********************************/void igCreateQuadricObject (int pu, int pv, float uMax, float vMax, float R, float s1, float s2){ /* pu es el numero de divisiones en u */ /* pv es el numero de divisiones en v*/ float u, v; float iniu,iniv; float inc_u; //incremento de u float inc_v; //incremento de v float x, y, z; /*almanezaran las coordenadas en el espacio tridimensional*/ int i,j;/*contadores para los bucles for*/ v= uMax; u =vMax; iniu=u; iniv=v; /*El maximo valor de u y v es 1 y el minimo es 0 por lo tanto debemos de distribuir las partes exigidas en la distancia establecida entre el valor de inicialización y el maximo valor*/ inc_u= (1.0f-u)/pu; inc_v= (1.0f-v)/pv; //Dibujamos los paralelos de la esfera //tantas circunfencias como partes de v for (j=0;j<pv;j++) { glBegin (GL_LINE_LOOP);//Indicamos a openGL el modo de dibujado //indicamos los puntos (partes de u) que formaran la circunferencia for (i= 0; i<= pu; i++) { x= xSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada x del punto y= ySuperQuadric (u, v, R, s1, s2);//indicamos la coordenada y del punto z= zSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada z del punto glVertex3f (x, y, z); //pintamos el punto en el espacio tridimensional u= u+ inc_u;//avanzamos hasta el siguiente putno //printf("valor de v=%f valor de u=%f\n",v,u); if (u>1){u=iniu;} } glEnd();//indicamos a openGL que hemos acabado de indicar los puntos de la circunferencia v+=inc_v;//avanzamos a la siguiente circunferencia paralela } u=iniu; v=iniv; //Dibujamos os meridianos de la esfera //tantos meridianos como partes de v for (j=0;j<pu;j++) { glBegin(GL_LINE_STRIP);//Indicamos a OpenGL el modo de dibujado //Indicamos los puntos (partes de v) que formaran el meridiano v=iniv; for(i=0;i<=pv;i++) { x= xSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada x del punto y= ySuperQuadric (u, v, R, s1, s2);//indicamos la coordenada y del punto z= zSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada z del punto glVertex3f (x, y, z); //pintamos el punto en el espacio tridimensional v+=inc_v;//avanzamos hasta el siguiente punto //printf("valor de v=%f valor de u=%f\n",v,u); } //printf("Meridiano dibujado\n\n"); glEnd();//Indicamos a openGL que ya hemos señalado los puntos del meridiano u+=inc_u;//avanzamos al siguiente meridiano }}void igWireSphere (int pu, int pv){ /* s1 y s2 a 1 */ igCreateQuadricObject(pu,pv,0,0,1.0, 1, 1);}void igWireRulo (int pu, int pv){ /* s1= 0.5, s2= 1 */ igCreateQuadricObject(pu,pv,0,0,1.0, 0.5, 1);}void igWireDado (int pu, int pv){ /* s1= 0.5, s2 =0.5 */ igCreateQuadricObject(pu,pv,0,0,1.0, 0.5, 0.5);}void igWireSemiSphere (int pu, int pv){ /* s1 y s2 a 1, uMax= 1, vMax= 0.5 */ igCreateQuadricObject(pu,pv,0,0.5,1.0, 1, 1);}void igWireCubo (void){ //Centramos en el origen de las coordenadas //El radio es 1 glBegin (GL_LINE_LOOP); //aristas traseras glVertex3f(-0.5,-0.5,-0.5); glVertex3f(0.5, -0.5, -0.5); glVertex3f(0.5,0.5,-0.5); glVertex3f(-0.5,0.5,-0.5); glVertex3f(-0.5,-0.5,-0.5); //parte delantera glVertex3f(-0.5,-0.5,0.5); glVertex3f(-0.5,0.5,0.5); glVertex3f(0.5,0.5,0.5); glVertex3f(0.5,-0.5,0.5); glVertex3f(-0.5,-0.5,0.5); //lado izquierdo glVertex3f(-0.5,-0.5,-0.5); glVertex3f(-0.5,-0.5,0.5); glVertex3f(-0.5,0.5,0.5); glVertex3f(-0.5,0.5,-0.5); glVertex3f(0.5,0.5,-0.5); glVertex3f(0.5,0.5,0.5); glVertex3f(0.5,-0.5,0.5); glVertex3f(0.5,-0.5,-0.5); glEnd ();}void igWireCone (int pu, int pv){/* s1= 2.0, s2= 1.0, uMax= 1.0, vMax= 0.5 */ igCreateQuadricObject(pu, pv, 0.5, 0, 1, 2.0, 1.0);}void CreaAbetoPush(void) { //abetoPush= glGenLists(1); if (abetoPush != 0) { glNewList( abetoPush, GL_COMPILE); glColor3f(1,0,0); glPushMatrix(); glRotated(180,0,0,1); glScalef(0.75, 1, 0.75); igWireCone(20, 20); glPopMatrix(); glPushMatrix(); glTranslatef(0,0.25, 0); glRotated(180,0,0,1); glScalef(0.75, 1, 0.75); glScalef(0.75, 1, 0.75); igWireCone(20, 20); glPopMatrix(); glPushMatrix(); glTranslatef(0, 0.5, 0); glRotated(180,0,0,1); glScalef(0.75, 1, 0.75); glScalef(0.75, 1, 0.75); glScalef(0.75, 1, 0.75); igWireCone(20, 20); glPopMatrix(); glPushMatrix(); glRotated(180,0,0,1); glScalef(0.75, 1, 0.75); glScalef(0.75, 1, 0.75); glScalef(0.75, 1, 0.75); glScalef(0.5, 1, 0.5); igWireRulo(15, 5); glPopMatrix(); glEndList(); } else { printf("Error al crear abetoPush\n"); } }void CreaAbeto (void){ //abeto = glGenLists (1); if (abeto != 0) /* Cero no es un identificador valido para una display list */ { glNewList (abeto, GL_COMPILE); /* Código para dibujar el abeto */ /*Sx=0.75 Sy=1.0 Sz=0.75*/ glColor3f(0,1,0); glRotated(180,0,0,1); glScalef(0.75,1,0.75); igWireCone(20, 20); glScalef(0.75,1,0.75); glTranslatef(0,-0.25,0); igWireCone(20, 20); glScalef(0.75,1,0.75); glTranslatef(0,-0.25,0); igWireCone(20, 20); glTranslatef(0, 0.5, 0); glScalef(0.5, 1, 0.5); igWireRulo(15, 5); glEndList (); }}void CreaEscalera(void) { int x; glNewList(escalera, GL_COMPILE); printf("mierda\n"); //# Dibuja una caja a modo de eje de la escalera de altura=2.0 y lado= 0.2 escalon(); for(x=0;x<100;x++) { glPushMatrix(); glRotated(90,1,0,0); //Sx=0.5 Sy= 0.05 Sz=0.1 glScalef(0.5, 0.5, 0.1); glTranslatef(0, 0,-x*(0.2)); glRotated((360/50)*x,0,0,1); escalon(); glPopMatrix(); } glEndList(); }void escalon(void) { glBegin (GL_LINE_LOOP); //base glVertex3f(-0.1,0,-0.1); glVertex3f(0.1,0,-0.1); glVertex3f(0.1,0,0.1); glVertex3f(-0.1,0,0.1); glVertex3f(-0.1,0,-0.1); //subimos glVertex3f(-0.1,2,-0.1); glVertex3f(0.1,2,-0.1); //bajamos y subimos glVertex3f(0.1,0,-0.1); glVertex3f(0.1,2,-0.1); glVertex3f(0.1,2,0.1); //bajamos y subimos glVertex3f(0.1,0,0.1); glVertex3f(0.1,2,0.1); glVertex3f(-0.1,2,0.1); //bajamos y subimos glVertex3f(-0.1,0,0.1); glVertex3f(-0.1,2,0.1); glVertex3f(-0.1,2,-0.1); glEnd(); }void CreaPatio(void) { int x; glNewList( patio , GL_COMPILE); for(x=0;x<12;x++) { glPushMatrix(); glScalef(0.2, 0.2, 0.2); glRotated(30*x, 0, 1, 0); glTranslatef(0, 0, -4); arco(); glPopMatrix(); } glEndList(); }void arco(void) { glPushMatrix(); //glColor3f(1, 0, 0);//rojo glTranslatef(-0.75, 0, 0); columna(); glPopMatrix(); glPushMatrix(); //glColor3f(0, 1, 0);//verde glTranslatef(0.75, 0, 0); columna(); glPopMatrix(); glPushMatrix(); //glColor3f(0, 0, 1);//azul glRotated(270, 0, 0, 1); glTranslatef(-1.75, -1, 0); columna(); glPopMatrix(); }void columna(void) { glBegin (GL_LINE_LOOP); //base glVertex3f(-0.25,0,-0.25); glVertex3f(0.25,0,-0.25); glVertex3f(0.25,0,0.25); glVertex3f(-0.25,0,0.25); glVertex3f(-0.25,0,-0.25); //subimos glVertex3f(-0.25,2,-0.25); glVertex3f(0.25,2,-0.25); //bajamos y subimos glVertex3f(0.25,0,-0.25); glVertex3f(0.25,2,-0.25); glVertex3f(0.25,2,0.25); //bajamos y subimos glVertex3f(0.25,0,0.25); glVertex3f(0.25,2,0.25); glVertex3f(-0.25,2,0.25); //bajamos y subimos glVertex3f(-0.25,0,0.25); glVertex3f(-0.25,2,0.25); glVertex3f(-0.25,2,-0.25); glEnd(); } |
tirando de archivo me encontre unas preguntitas de exámenes prácticos de talf:
Modelar el autómata tal que acepte el lenguaje que contenga palabras con 2 o más pares de ceros consecutivos .
Ej 0000 , 100100100 , 111111001100 , 11111100100100100
Tomado de la corrección en el primer comentario
Modelar el autómata tal que acepte el lenguaje que contenga palabras con como mínimo 4 ceros .
Modelar el autómata tal que acepte el lenguaje tal que 
Modelar el autómata tal que acepte el lenguaje tal que 
Modelar el autómata tal que acepte el lenguaje tal que acepte todos los binarios excepto los que contengan la subcadena 101.
Lo hacemos por el método del complemento primero modelamos un autómata que acepte palabras que contengan la subcadena 101.
aplicamos el metodo del complemento (los estados finales se transforman en no finales y viceversa)
Modelar el autómata tal que acepte el lenguaje binario tal que la tercera cifra por la derecha sea distinta a la segunda cifra por la izquierda.
Dado un alfabeto {a, b, c}, construir un AFD que acepte aquellas palabras que contengan al menos dos ‘a’, una ‘b’ y una ‘c’
teneis aqui el Autómata
1.- Dado el autómata finito no determinista descrito por la siguiente tabla, obtener el autómata finito determinista y posteriormente minimizarlo. El alfabeto que usa el autómata se compone de los símbolos: ∑ = {a,b}; el estado inicial es q0; y los estados finales q2 y q4.
modelamos el autómata en JFlap
Ahora es el momento de minimizarlo, primero debemos transformarlo en un AFD. para eso seleccionamos la opción (“Convert to DFA”) del menú Convert.
Pinchamos en Complete y finalmente en Done? lo que nos creara un AFD en una nueva ventana.
Pinchamos en la opción minimize DFA del menú convert para obtener el AFD mínimo
Pinchamos en el primer elemento del árbol de estados y pinchamos en el botón “Complete Subtree” para posteriormente pinchar en el botón “finish”
Esto creara una nueva ventana con el conjunto de estados.
pinchamos en “complete” para que cree los enlaces
y finalmente en “done” que nos mostrara una ventana con el AFD minimizado.
2.- Dado el autómata finito no determinista descrito por la siguiente tabla, obtener el autómata finito determinista y posteriormente minimizarlo. El alfabeto que usa el autómata se compone de los símbolos: ∑ = {0,1}; el estado inicial es q0; y el estado final q1.
modelamos el autómata en JFLAP
lo transformamos en un AFD siguiendo los pasos del ejercicio anterior.
y lo minimizamos igual que en el ejercicio anterior.
1. Vas a construir, paso a paso, una rutina que dibuje una supercuádrica. Esta función calcula un conjunto de puntos 3d de la superficie y al mismo tiempo los dibuja unidos mediante líneas utilizando la primitiva de OpenGL GL_LINE_LOOP. Para empezar, copia y pega la siguiente rutina en tu fichero glig.c. Observa el código y mira lo que ocurre al fijar el valor de v a 0.5 y hacer variar la u entre 0 y 1.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | void igCreateQuadricObject (float R, float s1, float s2){float u, v, inc_u;float x, y, z;int i, pu = 10; /* pu es el numero de divisiones en u */v= 0.5f;u =0.0f;inc_u= 1.0f/pu;glBegin (GL_LINE_LOOP);for (i= 0; i< 10; i++){x= xSuperQuadric (u, v, R, s1, s2);y= ySuperQuadric (u, v, R, s1, s2);z= zSuperQuadric (u, v, R, s1, s2);glVertex3f (x, y, z);u= u+ inc_u;}glEnd();} |
Llama a esta función con R, s1 y s2 a 1.0 desde la función Dibuja. Acuérdate de declararla en el fichero glig.h y de incluir este en examinar.c.
2. Si ya has entendido el código anterior, modifícalo para que la v también varíe entre 0 y 1 de forma que se dibuje una circunferencia para cada valor diferente de v. Como resultado debes obtener algo similar a la siguiente figura.
3. En el ejercicio anterior has conseguido dibujar los paralelos de la esfera. Ahora vas a dibujar los meridianos. Para ello, además de iterar la u entre 0 y 1 para cada valor de v, vas a iterar la v entre 0 y 1 para cada valor de u. Debes obtener un resultado similar al que se muestra en la siguiente figura
4. Ahora que ya has terminado la rutina vamos a añadir dos nuevos parámetros que permitan al usuario especificar el número de puntos que en u (pu) y en v (pv) se han de calcular (hasta ahora estaban fijados a 10. La declaración de la función es de la siguiente forma:
void igCreateQuadricObject (int pu, int pv, float R, float s1, float s2);
5. Para completar la función, vas a añadir dos nuevos parámetros que permitan acotar el rango de u y v de forma que puedan variar, cada uno de ellos, entre 0 y un valor especificado por el usuario (uMax, vMax). Con ello permitirás que se dibujen primitivas tales como medias esferas. La declaración de la función queda de la siguiente forma:
void igCreateQuadricObject (int pu, int pv, float uMax, float vMax, float R, float s1, float s2);
6. Añade las siguientes funciones a tu biblioteca de forma que cada una de ellas llame a la función igCreateQuadricObject con los parámetros oportunos para que dibuje la primitiva correspondiente en cada caso:
1 2 3 4 | void igWireSphere (int pu, int pv); /* s1 y s2 a 1 */void igWireRulo (int pu, int pv); /* s1= 0.5, s2= 1 */void igWireDado (int pu, int pv); /* s1= 0.5, s2 =0.5 */void igWireSemiSphere (int pu, int pv); /* s1 y s2 a 1, uMax= 1, vMax= 0.5 */ |
7. Añade a tu biblioteca la primitiva geométrica Cubo mediante la función void igWireCubo (void) . Esta primitiva debe tener de lado 1 y estar centrada en el origen de coordenadas. Haz un esquema en el papel para determinar en primer lugar los valores de las coordenadas de los ocho vértices. Después, crea una vector con las coordenadas de los vértices y, finalmente, escribe el código que dibuje sus aristas.
Las llamadas a función para dibujar las figuras se encuentran en la función IniciaCuadricas
examinar.h
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 | /*************************************************************************//* *//* examinar.h *//* Rev. 2.0 01/01/2002 AUTORES: O. Belmonte, M. Chover, J. Ribelles *//* *//*************************************************************************/#ifndef EXAMINAR_H#define EXAMINAR_H/* Variables Globales del modulo */int VentanaAncho = 500, VentanaAlto = 500; /* Tamanyo de la ventana */int VentanaX = 100, VentanaY = 100; /* Posicion de la ventana */GLdouble alfa = 0.0, beta = 0.0;GLuint cuadrica;/* Abre una ventana OpenGL */void AbreVentana (int numeroArgumentos, char ** listaArgumentos);/* Funcion de dibujado */void Dibuja(void);/* Establece el area visible */void TamanyoVentana (int alto, int ancho);/* Inicia las funciones de Callback */void IniciaFuncionesCallback (void);/* Define las acciones tras una pulsacion del teclado */void Teclado (unsigned char tecla, int x, int y);/* Define las acciones tras una pulsacion del teclado ampliado */void TecladoAmpliado (int tecla, int x, int y);/*Dibuja un Cubo*/void igWireCubo (void);void igCreateQuadricObject (int pu, int pv, float uMax, float vMax,float R, float s1, float s2);void igWireSphere (int pu, int pv); /* s1 y s2 a 1 */void igWireRulo (int pu, int pv); /* s1= 0.5, s2= 1 */void igWireDado (int pu, int pv); /* s1= 0.5, s2 =0.5 */void igWireSemiSphere (int pu, int pv); /* s1 y s2 a 1, uMax= 1, vMax= 0.5 */void salir();#endif |
examinar.c
001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 | /*************************************************************************//* *//* examinar.c *//* Rev. 2.0 01/01/2002 AUTORES: O. Belmonte, M. Chover, J. Ribelles *//* *//*************************************************************************//***************** INCLUDES DE LAS LIBRERIAS NECESARIAS ******************///#include <GL/freeglut.h>#include <GL/glut.h>#include <stdio.h>#include <stdlib.h>#include "examinar.h"#include "glig.h"/******************************************************************************************//* Establece el area visible y el tipo de proyeccion *//* Parametros: int ancho --> Ancho del area visible *//* int alto --> Alto del area visible *//* Salida: Ninguna *//******************************************************************************************/void TamanyoVentana (GLsizei ancho, GLsizei alto){/* Definicion del viewport */glViewport(0, 0, ancho, alto);/* Definicion de la vista */glMatrixMode(GL_PROJECTION);glLoadIdentity();glOrtho(-2.0, 2.0, -2.0*(GLfloat)alto/(GLfloat)ancho, 2.0*(GLdouble)alto/(GLfloat)ancho, -2.0, 2.0);}/******************************************************************************************//* Abre una ventana OpenGL *//* Parametros: int numeroArgumentos --> El numero de argumentos en la llamada al programa *//* char ** listaArgumentos --> Vector de cadenas con cada argumento *//* Salida: Ninguna *//******************************************************************************************/void AbreVentana (int numeroArgumentos, char ** listaArgumentos){glutInit(&numeroArgumentos, listaArgumentos);glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);glutInitWindowSize (VentanaAncho, VentanaAlto);glutInitWindowPosition (VentanaX, VentanaY);glutCreateWindow (listaArgumentos[0]);glutDisplayFunc (Dibuja);glutReshapeFunc (TamanyoVentana);glClearColor (0.0f, 0.0f, 0.0f, 0.0f); /* Establece el color de borrado */glClear (GL_COLOR_BUFFER_BIT); /* Borra el buffer de color */glColor3f (1.0f, 1.0f, 1.0f); /* Establece el color de dibujo */}/******************************************************************************************//* Define las acciones tras una pulsacion del teclado *//* Parametros: unsigned char key --> Codigo de la tecla pulsada *//* int x --> Coordenada x del cursor en el momento de pulsar la tecla *//* int y --> Coordenada y del cursor en el momento de pulsar la tecla *//* Salida: Ninguna *//******************************************************************************************/void Teclado (unsigned char tecla, int x, int y){switch (tecla){case 27 : /* Codigo de la tecla de Escape */exit(0);break;}}/******************************************************************************************//* Define las acciones tras una pulsacion del teclado ampliado *//* Parametros: unsigned char key --> Codigo de la tecla pulsada *//* int x --> Coordenada x del cursor en el momento de pulsar la tecla *//* int y --> Coordenada y del cursor en el momento de pulsar la tecla *//* Salida: Ninguna *//******************************************************************************************/void TecladoAmpliado (int tecla, int x, int y){switch (tecla){case GLUT_KEY_UP : /* Pulsacion cursor arriba del teclado ampliado */beta = beta + 15.0;if (beta > 360.0) beta = beta - 360.0;break;case GLUT_KEY_DOWN : /* Pulsacion cursor abajo del teclado ampliado */beta = beta - 15.0;if (beta < 0.0) beta = beta + 360.0;break;case GLUT_KEY_RIGHT : /* Pulsacion cursor derecha del teclado ampliado */alfa = alfa + 15.0;if (alfa > 360.0) alfa = alfa - 360.0;break;case GLUT_KEY_LEFT : /* Pulsacion cursor izquierda del teclado ampliado */alfa = alfa - 15.0;if (alfa < 0.0) alfa = alfa + 360.0;break;}glutPostRedisplay ();}/* Rutina de definiciÛn de eventos *//******************************************************************************************//* Inicia las funciones de callback *//* Parametros: Ninguno *//* Salida: Ninguna *//******************************************************************************************/void IniciaFuncionesCallback (void){glutKeyboardFunc (Teclado);glutSpecialFunc (TecladoAmpliado);}/******************************************************************************************//* Funcion de dibujado *//* Parametros: Ninguno *//* Salida: Ninguna *//******************************************************************************************/void Dibuja (void){glClear (GL_COLOR_BUFFER_BIT);/* Transformacion de la camara */glMatrixMode(GL_MODELVIEW);glLoadIdentity();glRotated (beta, 1.0,0.0,0.0);glRotated (-alfa, 0.0,1.0,0.0);glCallList (cuadrica);/* Objetos *///glutWireTeapot(1.0);//glutWireIcosahedron();//glutWireTetrahedron();//glutWireOctahedron();//glutWireDodecahedron();//glutWireTorus(0.2,0.9,18,20);//glutWireCone(0.5, 2.0, 14, 14);//glutWireCube(1.0);//glutWireSphere(1, 20,50);//igCreateQuadricObject(50,80,0,0,1.0, 1, 1);//igWireSphere (50, 50);//igWireRulo (200, 200);//igWireDado (60, 60);//igWireSemiSphere (50, 50); // s1 y s2 a 1, uMax= 1, vMax= 0.5 *///igWireCubo();glFlush();}void igCreateQuadricObject (int pu, int pv, float uMax, float vMax, float R, float s1, float s2){/* pu es el numero de divisiones en u *//* pv es el numero de divisiones en v*/float u, v;float iniu,iniv;float inc_u; //incremento de ufloat inc_v; //incremento de vfloat x, y, z; /*almanezaran las coordenadas en el espacio tridimensional*/int i,j;/*contadores para los bucles for*/v= uMax;u =vMax;iniu=u;iniv=v;/*El maximo valor de u y v es 1 y el minimo es 0 por lo tanto debemos de distribuirlas partes exigidas en la distancia establecida entre el valor de inicialización yel maximo valor*/inc_u= (1.0f-u)/pu;inc_v= (1.0f-v)/pv;//Dibujamos los paralelos de la esfera//tantas circunfencias como partes de vfor (j=0;j<pv;j++){glBegin (GL_LINE_LOOP);//Indicamos a openGL el modo de dibujado//indicamos los puntos (partes de u) que formaran la circunferenciafor (i= 0; i<= pu; i++){x= xSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada x del puntoy= ySuperQuadric (u, v, R, s1, s2);//indicamos la coordenada y del puntoz= zSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada z del puntoglVertex3f (x, y, z); //pintamos el punto en el espacio tridimensionalu= u+ inc_u;//avanzamos hasta el siguiente putno//printf("valor de v=%f valor de u=%f\n",v,u);if (u>1){u=iniu;}}glEnd();//indicamos a openGL que hemos acabado de indicar los puntos de la circunferenciav+=inc_v;//avanzamos a la siguiente circunferencia paralela}u=iniu;v=iniv;//Dibujamos os meridianos de la esfera//tantos meridianos como partes de vfor (j=0;j<pu;j++){glBegin(GL_LINE_STRIP);//Indicamos a OpenGL el modo de dibujado//Indicamos los puntos (partes de v) que formaran el meridianov=iniv;for(i=0;i<=pv;i++){x= xSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada x del puntoy= ySuperQuadric (u, v, R, s1, s2);//indicamos la coordenada y del puntoz= zSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada z del puntoglVertex3f (x, y, z); //pintamos el punto en el espacio tridimensionalv+=inc_v;//avanzamos hasta el siguiente punto//printf("valor de v=%f valor de u=%f\n",v,u);}//printf("Meridiano dibujado\n\n");glEnd();//Indicamos a openGL que ya hemos señalado los puntos del meridianou+=inc_u;//avanzamos al siguiente meridiano}}void igWireSphere (int pu, int pv){/* s1 y s2 a 1 */igCreateQuadricObject(pu,pv,0,0,1.0, 1, 1);}void igWireRulo (int pu, int pv){/* s1= 0.5, s2= 1 */igCreateQuadricObject(pu,pv,0,0,1.0, 0.5, 1);}void igWireDado (int pu, int pv){/* s1= 0.5, s2 =0.5 */igCreateQuadricObject(pu,pv,0,0,1.0, 0.5, 0.5);}void igWireSemiSphere (int pu, int pv){/* s1 y s2 a 1, uMax= 1, vMax= 0.5 */igCreateQuadricObject(pu,pv,0,0.5,1.0, 1, 1);}void igWireCubo (void){//Centramos en el origen de las coordenadas//El radio es 1glBegin (GL_LINE_LOOP);//aristas traserasglVertex3f(-0.5,-0.5,-0.5);glVertex3f(0.5, -0.5, -0.5);glVertex3f(0.5,0.5,-0.5);glVertex3f(-0.5,0.5,-0.5);glVertex3f(-0.5,-0.5,-0.5);//parte delanteraglVertex3f(-0.5,-0.5,0.5);glVertex3f(-0.5,0.5,0.5);glVertex3f(0.5,0.5,0.5);glVertex3f(0.5,-0.5,0.5);glVertex3f(-0.5,-0.5,0.5);//lado izquierdoglVertex3f(-0.5,-0.5,-0.5);glVertex3f(-0.5,-0.5,0.5);glVertex3f(-0.5,0.5,0.5);glVertex3f(-0.5,0.5,-0.5);glVertex3f(0.5,0.5,-0.5);glVertex3f(0.5,0.5,0.5);glVertex3f(0.5,-0.5,0.5);glVertex3f(0.5,-0.5,-0.5);glEnd ();}void IniciaCuadricas (void){cuadrica = glGenLists (1);if (cuadrica != 0) /* Cero no es un identificador valido para una display list */{glNewList (cuadrica, GL_COMPILE);//igCreateQuadricObject (20,20,0,0,1.0f, 1.0f, 1.0f);//igWireCubo();//igWireDado(20,20);//igWireRulo(10, 20);igWireSemiSphere(20,20);glEndList ();}}/******************************************************************************************//* Funcion principal *//* Parametros: int numeroArgumentos --> El numero de argumentos en la llamada al programa *//* char ** listaArgumentos --> Vector de cadenas con cada argumento *//* Salida: Un entero que se devuelve al sistema al acabar la ejecucion del programa *//******************************************************************************************/int main(int numArgumentos, char ** listaArgumentos){/* CreaciÛn de la ventana de la aplicaciÛn */AbreVentana (numArgumentos, listaArgumentos);/* Rutinas para el control de eventos */IniciaFuncionesCallback ();IniciaCuadricas();/* A la espera de eventos.... */glutMainLoop();return (0);} |
P1: ¿Qué lenguajes definen las siguientes expresiones regulares?
empezamos a descomponer la expresión regular a partir de los nodos finales (marcados en rojo).
Paso 1: intentamos minimizar los nodos finales: en esta expresión no se puede
Paso 2:Describimos el lenguaje de cada nodo final:
: cero o mas repeticiones de la cadena 01
: Cadena 0
:cero o mas repeticiones de la cadena 10
: Cadena 1
subimos al nivel anterior y unimos los nodos en los que sus elementos siguientes estén descritos hasta que lleguemos a la raíz del árbol.
miramos si podemos minimizar los nodos a describir (marcados de rojo), en este caso no podemos.
asi que describimos los nodos en los que nos encontramos
: cero o mas repeticiones de la cadena 01 unidas con 0
:cero o mas repeticiones de la cadena 10 unidos con 1nueva iteración. subimos al nivel superior
miramos si podemos minimizar los nodos a describir (marcados de rojo), en este caso no podemos.
asi que describimos los nodos en los que nos encontramos
: cero o mas repeticiones de la cadena 01 ó cero o mas repeticiones de la cadena 01 unidas con 0subimos
Describimos la expresión regular uniendo los elementos anteriores (+=0) (*=y)
cero o mas repeticiones de la cadena 01 ó cero o mas repeticiones de la cadena 01 unidas con 0, o cero o mas repeticiones de la cadena 10 unidos con 1
Expresión regular numero 2: 
Paso 1: Descomponemos la expresión regular en pequeñas expresiones.
marcamos los nodos finales
Minimizamos los nodos finales, en este caso no se puede
Describimos los nodos finales
: la cadena 1 o nada
: cero o mas repeticiones de la cadena 01
:la cadena 0 o nadasubimos al siguiente nivel de la estructura
intentamos minimizar la expresión actual: no se puede
Describimos la expresión actual.
:la cadena 1 o nada unida a cero o mas repeticiones de la cadena 01 unida a la cadena 0 o nada
Paso 1: Descomponemos la expresión regular en pequeñas expresiones.
marcamos los nodos finales
intentamo minimizar algún nodo final en este caso si que podemos
empezamos a minimizar hacia arriba y nos queda la siguiente expresión minimizada
describimos las expresiones del segundo nivel
: la cadena 01
: cero o mas repeticiones de la cadena con 0 o mas repeticiones de cero o de la cadena 01
: la cadena 1por lo tanto el lenguaje que define esta expresión regular es: la cadena 01 o cero o mas repeticiones de la cadena con 0 o mas repeticiones de cero o de la cadena 01 unido a la cadena 1
P2: Escribe una expresión regular sobre el alfabeto {a, b, c} que define todas las palabras que tengan dos a’s consecutivos o dos b’s consecutivos.
(a+b+c)*.((aa)+(bb)).(a+b+c)*
P3: Construye según procedimiento visto en clase un AFND–ε que acepta las mismas palabras que define la expresión regular de P1 apartado 2.
modelamos las pequeñas expresiones el las que hemos descompuesto la expresión 2:
Ahora unimos las partes en un autómata .
1.- Dado el AFND- ε afnd1
a. Marcar los estados no deterministas
Pinchamos en Test -> Highlight NonDeterminism
b. Marcar las transacciones ε (λ)
Pinchamos en Test -> Highlight λ-Transitions
c. Indica la traza de todos los caminos recorridos hasta aceptar o no aceptar
las palabras:
NOTA: utiliza para ello todas las opciones del Step by State (Step,Reset,Freeze,Thaw,Trace, Remove)
2.-Modela un autómata sobre el paso de una persona de un estado civil a otro: tener en cuenta al menos los estados civiles “soltero”, “casado”, “divorciado”, “viudo”. Considere al divorcio como un proceso con duración (instantáneo).
3.-Diseñar usando el método del complemento un AFD que acepte las palabras en {a, b} que no inicien con abab.
4.- Construir autómatas finitos deterministas que acepten cada uno de los lenguajes siguientes.
a. 
b. Los números binarios en los que la primera cifra es diferente de la última.
c. Todas las cadenas sobre 
que contienen al menos una vez cada símbolo de 
.
Enunciado de la practica Enunciado Practica 3 Talf.
1.-Introduce en JFlap el siguiente autómata e intenta averiguar que lenguaje describe
Para averiguar que lenguaje genera el autómata la forma mas intuitiva es transformarlo en una expresión regular, en el menu de JFlap seleccionamos “Convert->Convert FA to RE”
pinchamos en el boton “Do It” el cual generara transiciones vaciás entre estados
Volvemos a pinchar en “Do It” para eliminar estados no iniciales o no finales
la etiqueta de informacion situada debajo de la pestaña de conversión nos indica que la transformación de autómata finito a expresion regular esta completada, por lo tanto ya podemos pinchar en el botón Export el cual creara una nueva ventana mostrándonos la expresión regular
por lo tanto el lenguaje que crea este autómata esta compuesto por un numero de caracteres (a>=0) una letra b y un numero de repeticiones de la cadena bb>=0
2.- Modela el autómata que reconozca cadenas con un número par de “0”s y “1”s
Partimos de que 0 es par por lo tanto ε es una palabra valida, y el estado inicial.
Los posibles estados para este autómata son:
creamos un nuevo autómata en JFlap introduciendo los cuatro posibles estados:
habíamos quedado en que ε tiene un numero par de 0’s y un numero par de 1’s por lo tanto 1P0P es estado inicial y final. Asi que lo que nos queda es completar las transiciones.
3.- Autómata que reconozca cadenas impares de de “0”s y “1”s
igual que el apartado anterior pero cambiando el estao final en lugar de 1P0P es 1I0I
4.- Construye un AFD que acepte identificadores, con las siguientes características
a. Solo letras vocales minúsculas
b. Es válido el carácter de subrayado, con la condición que como máximo exista uno
c. No se permiten espacios en blanco
d. También puede tener números, pero no pueden estar al principio ni al final del identificador, ni haber más de tres consecutivos
P1: Convierte el siguiente AFND–ε en un AFND (incluye todas las tablas, grafos, quintuplas, y el cálculo de la clausura transitiva necesario). El estado inicial es el estado 1.
Hagamos memoria una quintupla se representa por esta formula 
donde:
es un alfabeto
es un conjunto finito no vació de estados
es una función de transición
es el estado inicialPara el AFND–ε la quintupla estará formada por:
={a,b,ε}={1,2,3,4,5,6}la tabla de transición={1}Creamos la tabla de transición para el AFND-ε
| Elemento | a | b |
|
|---|---|---|---|
|
1 |
{6} | { } |
{2} |
|
2 |
{3} | {2} | {} |
|
3 |
{4} | {} |
{6} |
|
4 |
{} |
{3,5} | {} |
|
5 |
{3} | {} |
{} |
|
6 |
{} |
{5} | {4} |
ahora calculamos las clausuras para cada elemento
Por clausura de un elemento entendemos el conjunto de estados a los que podemos acceder sin consumir ninguna símbolo , el propio elemento al que le calculamos su clausura pertenecerá a la misma.
para que quede mas claro, para el elemento 3 su clausuara estara compuesta por 3, 6 “(3,ε)=6” y 4 “(6,ε)=4”
| Elemento | a | b |  |
clausura |
|---|---|---|---|---|
| 1 | {6} | {} |
{2} | {1,2} = Cl(1) |
| 2 | {3} | {2} | {} |
{2} = Cl(2) |
| 3 | {4} | {} |
{6} | {3,6,4} = Cl(3) |
| 4 | {} |
{3,5} | {} |
{4} = Cl(4) |
| 5 | {3} | {} |
{} |
{5} = Cl(5) |
| 6 | {} |
{5} | {4} | {6,4} = Cl(6) |
Ahora creamos una nueva tabla eliminando la columna de ε y substituyendo los estados de destino para cada elemento del alfabeto por la unión de los estados de destino de la clausura. Por ejemplo para el elemento 1 la clausura es {1,2} y para la transición con a debemos incluir 6 para el estado 1 y 3 para el estado 2. por lo tanto nos queda el conjunto {6,3}.
 |
a | b |
|---|---|---|
| Cl(1) |
{6,3} |
{2} |
| Cl(2) |
{3} |
{2} |
| Cl(3) |
{4} |
{3,5} |
| Cl(4) | {} |
{3,5} |
| Cl(5) |
{3} |
{} |
| Cl(6) | {} |
{3,5} |
una vez realizada esta tabla creamos la ultima tabla substituyendo cada estado destino de la tabla anterior por la clausura del mismo
| |
a | b |
|---|---|---|
| Cl(1) |
{3,4,6} |
{2} |
| Cl(2) |
{3,4,6} |
{2} |
| Cl(3) |
{4} |
{3,4,5,6} |
| Cl(4) |
{ |
{3,4,5,6} |
| Cl(5) |
{3,4,6} |
{ |
| Cl(6) |
{ |
{3,4,5,6} |
Ahora ajustamos los estados para añadir los iniciales y los finales. Si en la clausura de un elemento existe un estado inicial este es inicial (marcados verde en la segunda tabla) y si existe un estado final este es final (marcados de rojo en la segunda tabla) con esto ya tenemos el AFND sin transiciones epsilon
| |
a | b |
|---|---|---|
| *->Cl(1) |
{3,4,6} |
{2} |
| *Cl(2) |
{3,4,6} |
{2} |
| *Cl(3) |
{4} |
{3,4,5,6} |
| *Cl(4) |
{ |
{3,4,5,6} |
| Cl(5) |
{3,4,6} |
{ |
| *Cl(6) |
{ |
{3,4,5,6} |
Para el AFND la quintupla estará formada por:
={a,b}={1,2,3,4,5,6}la tabla de transición={1}Modelamos el nuevo autómata en JFlap
Cargamos el otro en JFlap
En la ventana de cualquier autómata seleccionamos el menú test y la opción “compare equivalence” y seleccionamos el otro automata
pinchamos en aceptar y son equivalentes
lo que significa que aceptan el mismo lenguaje
