Posibles preguntas para el primer examen practico de TALF

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

autómata que contenga dos pares de ceros consecutivos

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 .

minimo 4  cerosModelar el autómata tal que acepte el lenguaje tal que { a^n b^m / n>= 1 y m>=2 }

una a dos besModelar el autómata tal que acepte el lenguaje tal que formula_3

tres a dos b alguna cModelar 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.

acepta subcadena 101aplicamos el metodo del complemento (los estados finales se transforman en no finales y viceversa)

no acepta subcadena 101

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.

segundo izquierda distinto tercero derechaDado un alfabeto {a, b, c}, construir un AFD que acepte aquellas palabras que contengan al menos dos ‘a’, una ‘b’ y una ‘c’

dos a una b una cteneis aqui el Autómata

Practica 5 TALF

Enunciado practica 5

Autómatas finitos no deterministas

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.

tabla autómata 1modelamos el autómata en JFlap

autómata sin minimizar 1Ahora es el momento de minimizarlo, primero debemos transformarlo en un AFD. para eso seleccionamos la opción (“Convert to DFA”) del menú Convert.

convirtiendo a AFD

Pinchamos en Complete y finalmente en Done? lo que nos creara un AFD en una nueva ventana.

AFD convertido

Pinchamos en la opción minimize DFA del menú convert para obtener el AFD mínimo

minimizando

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.

conjunto de estados

pinchamos en “complete” para que cree los enlaces

enlaces creados

y finalmente en “done” que nos mostrara una ventana con el AFD minimizado.

AFD minimo

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.

tabla autómata 2

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.

Practica 4 TALF

Enunciado Practica 4

afnd1

1.- Dado el AFND- ε afnd1
a. Marcar los estados no deterministas

Pinchamos en Test ->  Highlight NonDeterminism

Estados no deterministas marcados

b. Marcar las transacciones ε (λ)

Pinchamos en Test ->  Highlight λ-Transitions

transiciones epsilon

c. Indica la traza de todos los caminos recorridos hasta aceptar o no aceptar
las palabras:

  • aaabbaab
    • No existen trazas en las que  acepte el automa
    • Trazas que no aceptan
  • aaaaaabbbbbb
    • Trazas que Acepta
    • Trazas que no Acepta

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).

estados civiles

3.-Diseñar usando el método del complemento un AFD que acepte las palabras en {a, b} que no inicien con abab.

metodo complemento

4.- Construir autómatas finitos deterministas que acepten cada uno de los lenguajes siguientes.
a.

no 4 as

b. Los números binarios en los que la primera cifra es diferente de la última.

numeros binarios
c. Todas las cadenas sobre  que contienen al menos una vez cada símbolo de  .

todos los símbolos del alfabeto

Practica 3 TALF

Enunciado de la practica Enunciado Practica 3 Talf.

1.-Introduce en JFlap el siguiente autómata e intenta averiguar que lenguaje describe

autómata ejercicio 1Para 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”

Convert FA to REpinchamos en el boton “Do It” el cual generara transiciones vaciás entre estados

Empty trasitions addedVolvemos a pinchar en “Do It” para eliminar estados no iniciales o no finalesintermediate states eliminated

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

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:

  • Numero de 1’s par y numero de 0’s par
  • Numero de 1’s par y numero de 0’s impar
  • Numero de 1’s impar y numero de 0’s par
  • Numero de 1’s impar y numero de 0’s impar

creamos un nuevo autómata en JFlap introduciendo los cuatro posibles estados:

estados autómatahabí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.

automata numero de unos paresy numero de  ceros pares3.- 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

automata unos impares ceros impares4.- 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

automata 4

Hoja 5 (23 de Marzo de 2010)

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.

AFND-E hoja 5

Hagamos memoria una quintupla se representa por esta formula Quintupla base donde:

  • Alfabetoes un alfabeto
  • conjunto de estadoses un conjunto finito no vació de estados
  • funcion de Transiciones una función de transición
  • conjunto de estados inicialeses el estado inicial
  • F es el conjunto de estados finales

Para el AFND–ε la quintupla estará formada por:

  • Alfabeto={a,b,ε}
  • conjunto de estados={1,2,3,4,5,6}
  • funcion de Transicionla tabla de transición
  • conjunto de estados iniciales={1}
  • F={2,4}

Creamos la tabla de transición para el AFND-ε

Elemento a b

epsilon

1

{6} {emptyset} {2}

2

{3} {2} {emptyset}

3

{4} {emptyset} {6}

4

{emptyset} {3,5} {emptyset}

5

{3} {emptyset} {emptyset}

6

{emptyset} {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 epsilon clausura
1 {6} {emptyset} {2} {1,2} = Cl(1)
2 {3} {2} {emptyset} {2} = Cl(2)
3 {4} {emptyset} {6} {3,6,4} = Cl(3)
4 {emptyset} {3,5} {emptyset} {4} = Cl(4)
5 {3} {emptyset} {emptyset} {5} = Cl(5)
6 {emptyset} {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}.

delta a b
Cl(1)

{6,3}

{2}

Cl(2)

{3}

{2}

Cl(3)

{4}

{3,5}
Cl(4) {emptyset} {3,5}
Cl(5)

{3}

{emptyset}
Cl(6) {emptyset} {3,5}

una vez realizada esta tabla creamos la ultima tabla substituyendo cada estado destino de la  tabla anterior por la clausura del mismo

delta a b
Cl(1)

{3,4,6}

{2}

Cl(2)

{3,4,6}

{2}

Cl(3)

{4}

{3,4,5,6}

Cl(4)

{emptyset}

{3,4,5,6}

Cl(5)

{3,4,6}

{emptyset}

Cl(6)

{emptyset}

{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

delta a b
*->Cl(1)

{3,4,6}

{2}

*Cl(2)

{3,4,6}

{2}

*Cl(3)

{4}

{3,4,5,6}

*Cl(4)

{emptyset}

{3,4,5,6}

Cl(5)

{3,4,6}

{emptyset}

*Cl(6)

{emptyset}

{3,4,5,6}

Para el AFND la quintupla estará formada por:

  • Alfabeto={a,b}
  • conjunto de estados={1,2,3,4,5,6}
  • funcion de Transicionla tabla de transición
  • conjunto de estados iniciales={1}
  • F={1,2,3,4,6}

Modelamos el nuevo autómata en JFlap

AFND Cargamos el otro en JFlap

dos autómatasEn la ventana de cualquier autómata seleccionamos el menú  test y la opción “compare equivalence” y seleccionamos el otro automata

comparar dos autómatas

pinchamos en aceptar y son equivalentes

son equivalenteslo que significa que aceptan el mismo lenguaje

TALF Hoja 4 (16 de Marzo de 2010)

P1: Convierte el AFND de la hoja anterior en un autómata finito determinista. Incluye en tu solución la tabla de conversión tal como lo vimos en clase, la quintupla del AFD obtenido finalmente, y su grafo.

Partimos del siguiente AFND.

AFND BaseAñadimos el estado de Error.

AFND Base con estado de error

Comenzamos a crear la tabla de conversión

partimos del estado inicial {a}. con 0 vamos a {a} y con 1 a {a,b}

Tabla AFND AFD paso 1{a} ya pertenece al conjunto de estados, pero {a,b} no por lo tanto añadimos el estado {a,b}.

Tabla AFND AFD paso 2en el conjunto {a,b} con valor 0  a nos lleva a {a} y b nos lleva a {c,d} por lo tanto {a,b} con 0 nos lleva a {a,c,d} como {a,c,d} no esta en el conjunto de estados lo añadimos y añadimos las transiciones.

Tabla AFND AFD paso 3repetimos el procedimiento hasta que no se creen mas elementos para el conjunto de estados. quedándonos la siguiente tabla (a menos que me haya equivocado)

Tabla AFND AFD paso final

ahora pasamos la tabla a un grafo.

AFD sin estados finales ni inicialesLos primeros estados iniciales de nuestro AFND “con los que empezamos la tabla” son nuestros estados iniciales, en esta caso A.

AFD sin estados finales pero con inicialesTodo estado del AFD donde exista un estado final del AFND es final (en este caso todos donde este d)

AFD convertidoFinalmente la quintupla queda definida por:
M=(∑,Q,δ,q0,F)

siendo

  • ∑   El alfabeto
  • Q   Conjunto finito de estados
  • δ    la función de transición
  • q0 conjunto de estados iniciales
  • F    conjunto de estados finales
por lo tanto para este AFD la quintupla sera:
  • ∑   {0,1}
  • Q    [{a},{a,b},{a,c,d},{a,b,c},{a,d,error},{a,b,d,error},{a,b,c,d},{a,error},{a,b,error},{a,c,d,error},{a,b,c,error},{a,b,c,d,error}]
  • δ    es la tabla de transiciones
  • q0 {a}
  • F     [{a,c,d},{a,d,error},{a,b,d,error},{a,b,c,d},{a,c,d,error},{a,b,c,d,error}]

Practica 1 Informática Gráfica ultimo ejercicio

El codigo aqui:

/*
* File:   main.c
* Author: luzem
*
* Created on 17 de marzo de 2010, 1:08
*/

#include <stdio.h>
#include <stdlib.h>
#include "GL/freeglut.h" //Alternativa a Glut.h
/******************************************************************/
/* Funcion de dibujado                                            */
/* Parametros: Ninguno                                            */
/* Salida: Ninguna                                                */
/******************************************************************/
void Dibuja(void) {
float altura = 1;
float base = -0.5f;
/* Establece el color de borrado */
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

/* Borra el buffer de color */
glClear(GL_COLOR_BUFFER_BIT);

/* Establece el color de dibujo */
glColor3f(1.0f, 1.0f, 1.0f);

/* Crea un poligono 2D (cuadrado) */
glBegin(GL_POLYGON);
glVertex2f(-0.5f, -0.5f);
glVertex2f(-0.5f, 0.5f);
glVertex2f(0.5f, 0.5f);
glVertex2f(0.5f, -0.5f);
glEnd();
int x;
for (x = 0; x < 5; x++) {
if (x % 2 == 0) {
//cuadrado par pintamos de negro
glColor3f(0, 0, 1);
} else {
//cuadrado impar pintamos de verde
glColor3f(0, 1, 0);
}
glBegin(GL_POLYGON);
glVertex2f(base, base);
glVertex2f(base, base + altura);
glVertex2f(base + altura, base + altura);
glVertex2f(base + altura, base);
glEnd();
altura = altura - 0.2;
base = base - 0.02;
}

/* Se asegura de que se ejecutan todas las ordenes */
glFlush();
}

/******************************************************************************************/
/* Establece el area visible                                                              */
/* Parametros: int ancho --> Ancho del area visible                                       */
/*             int alto --> Alto del area visible                                         */
/* Salida: Ninguna                                                                        */

/******************************************************************************************/
void TamanyoVentana(int ancho, int alto) {
glViewport(0, 0, ancho, alto);
}

/******************************************************************************************/
/* Inicia las propiedades de la vista                                                     */
/* Parametros: Ninguno                                                                    */
/* Salida: Ninguna                                                                        */

/******************************************************************************************/
void IniciaVista(void) {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.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(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow(listaArgumentos[0]);
glutDisplayFunc(Dibuja);
glutReshapeFunc(TamanyoVentana);
IniciaVista();
}

/******************************************************************************************/
/* 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) {
/* Crea la ventana de la aplicaci¢n */
AbreVentana(numArgumentos, listaArgumentos);

/* Establece el bucle principal de control de OpenGL */
glutMainLoop();

return (0);
}

El resto de la película en libreta de notas enjoy.

Ejercicio 2 Teoria TALF

p1: Dados dos lenguajes y sobre el alfabeto . Anotamos con la unión, con la intersección, el complemento y con la diferencia.

Verifica o contradice:

    • Cierto: supongamos que  es un lenguaje que genera palabras de la forma  comprenderá todas las palabras sobre el alfabeto excepto las que cumplan la forma  si a  le sacamos el sublenguaje generado por  obtendremos el mismo resultado.
    • cierto:supongamos que es un lenguaje que genera palabras de la forma  y que  genera el lenguaje  por lo tanto generaran un lenguaje de la forma   por lo tanto  serán todas las combinaciones del lenguaje  excepto las que cumplan con el patrón .
      serán todas las palabras del lenguaje  excepto las que cumplan la forma .
      serán todas las palabras del lenguaje excepto las que cumplan la forma .
      por lo tanto la intersección de ambos lenguaje serán todas las palabras de   excepto las que cumplan el patrón .
    • cierto: La intersección de  y   serán las palabras comunes entre los dos sublenguajes y su complemento sera  para la segunda parte de la ecuación
    • Falso con  generaríamos palabras de la forma  y con  generaríamos palabras de la forma  .

p2: Construye un autómata finito determinista que “acepta” el lenguaje L que contiene todas las palabras (finitas) sobre el alfabeto {0, 1} con un número par de 0s y un número impar de 1s.

El modelo del autómata en JFlap lo podéis descargar en este enlace: autómata practica 2

Edit: Corregido el autómata que tenia mal un enlace, un 0 en lugar de un 1. Muchas gracias a Ymourino

Practica 1 Talf

Búsquedas basadas en Expresiones Regulares

El objetivo de la práctica es utilizar herramientas del sistema operativo como por
ejemplo Word en Windows para hacer búsquedas en archivos .doc; y greo o egrep
para buscar en archivos de texto plano.

Buscar en el “Himno Galego” o “Conxuro da Queimada” usando Word.

  • Palabras completas. Por ejemplo “de” “dos” “terra” o cualquiera que se te ocurra.
    • <na>
      <dos>
      <terra>
  • Palabras que comiencen por una letra o conjunto de ellas. Por ejemplo palabras que comiencen por “de”.
    • <de
  • Que además de comenzar por un conjunto de letras, estén al principio de una línea. Líneas que empiecen por “de”.
    • ^v<de
  • Palabras que terminen con una letra o conjunto de letras. Por ejemplo, palabras que terminen en “os” o “en”.
    • os>^l  
      en>^l
  • Que además de terminar en un conjunto de letras estén al final o al principio de una línea.
    • >as^| (no funciona)
  • Palabras que tienen dos vocales “a”.
    • [a-z,A-Z]@a[a-z,A-Z]@a

Buscar en el archivo de personas que contienes nombres de personas e información adicional sobre ellas (correo, ciudad, teléfono). Usando grep.

  • Personas que se llaman Carlos, mostrando la línea que ocupan en la lista.
    • cat personas.txt | grep -n “Carlos”
  • Personas cuyo nombre comience por las letras comprendidas entre M y S.
    • cat personas.txt | grep -n “[MS]”
  • Líneas del archivo de personas que contengan por lo menos diez letras mayúsculas consecutivas.
    • cat personas.txt | grep “[A-Z][A-Z][A-Z][A-Z][A-Z][A-Z][A-Z][A-Z][A-Z][A-Z]”
  • Líneas que tengan su dirección de correo electrónico en el servidor uvigo.
    • cat personas.txt | grep “@uvigo”
  • Personas cuyo nombre comience por la letra “E” o “M”.
    • cat personas.txt | grep “^[EM]”
  • Personas cuyo número de teléfono termine en 21.
    • cat personas.txt | grep “21$”
  • Personas cuyo prefijo de teléfono sea el 988
    • cat personas.txt | grep ” 988″
  • Otras búsquedas que se te ocurran.

Archivos conxuro himno personas