domingo, 31 de diciembre de 2017

Minshuu No Teki: Resincronizacion subtitulos episodio 8.

Como os dije, aqui os traigo la resincronizacion del episodio 8 a la version de Fumei.

Un saludo.

Minshuu no Teki: Dia 22. Fin del noveno episodio.



Para terminar el año con buen pie os traigo el penúltimo episodio, porque la programacion especial de la tele en nochevieja es, no nos engañemos, una pesadez.

Bueno, me han quedado un poco artificiales algunas frases, pero creo que está aceptable. Al menos es mejor que los subtitulos originales, que ¿os podeis creer que han cambiado a un personaje de nombre en los subtitulos?

Vamos a por las estadisticas. He hecho una sesion de una hora y 48 minutos con las lineas 206-823. Eso son 5.71 lineas por minuto.

En total tardé 147 minutos en hacer el episodio completo, lo que son 5.60 lineas por minuto.

Aqui os dejo el enlace.


Tema aparte: por lo visto la version de Fumei y la que habia colgado del episodio 8 no están sincronizadas. Intentaré echarle un vistazo, pero no se si tendré tiempo.

Un saludo y feliz año.

sábado, 30 de diciembre de 2017

Minshuu no Teki: Dia 21. Torrent completo.

Por fin tengo el torrent completo (gracias, Fran). Ya solo quedan los dos últimos episodios, y parece que acabaré la serie el año que viene.

Eso si, quiero pediros un favor. Si no me equivoco hay tres episodios que hice con unas raws distintas a las de Fumei, con lo que necesitaría que comprobaseis si están correctamente sincronizados, para poder ajustar los tiempos si no es así.

Aqui os lo dejo.


Y ahora las estadisticas. 205 lineas, 39 minutos. 5.26 lineas por minuto. Parece que me estoy amoldando bien al teclado nuevo.

Un saludo, y por si no publico mañana, que tengais un feliz año.

lunes, 25 de diciembre de 2017

Practica PL1 (2017-2018): Parte 2 - Analizador sintáctico (IV)

Tras una pequeña pausa (entre otras cosas por un problema con Eclipse) retomo la resolucion de la practica. Ahora tocan las definiciones de procedimientos.

Aqui tenemos una de las partes que se diferencia entre ambos grupos de la practica, asi como mi enfoque de hacer TODA la especificacion.

Además, la documentacion está mal diseñada e incompleta, con lo que es necesario recurrir a los casos de prueba para realizar el diseño.

Veamos una serie de ejemplos validos de la primera linea de la declaracion de un procedimiento:

PROCEDURE proc0;
PROCEDURE proc1(var1,var2:INTEGER;var3:BOOLEAN);
PROCEDURE proc2(var1,var2:INTEGER;var3:BOOLEAN): BOOLEAN;
PROCEDURE proc3(VAR var1,var2:INTEGER; VAR var3:BOOLEAN):INTEGER;
PROCEDURE proc4:INTEGER;
PROCEDURE proc5:tipoCompuesto;
PROCEDURE proc6(VAR var1, var2: INTEGER; var3:BOOLEAN): tipoCompuesto;

Todos estos son validos o no, dependiendo del grupo al que se pertenezca, y el ultimo no es valido en ninguno de los grupos, pero si en mi especificacion.

A esta primera linea la voy a denominar "cabecera", y voy a seguir definiendo.

declaracionProcedimientos::=declaracionProcedimiento declaracionProcedimientos|/*epsilon*/;
declaracionProcedimiento::= cabecera declaraciones BEGIN sentencias END IDENTIFICADOR PUNTOYCOMA;

Esto es basicamente una copia de la descripcion del programa que lo contiene, e incluye la posibilidad de anidar procedimientos.

Vamos ahora a la cabecera y a cada uno de sus campos.

declaracionProcedimiento::= PROCEDURE IDENTIFICADOR argumentos tipoSalida PUNTOYCOMA;

argumentos::= /*epsilon*/|ABRIR_PARENTESIS listaArgumentos CERRAR_PARENTESIS;

listaArgumentos::= listaIdentificadores DOSPUNTOS tipoPrimitivo
      |listaIdentificadores DOSPUNTOS IDENTIFICADOR
      |listaIdentificadores DOSPUNTOS tipoPrimitivo PUNTOYCOMA listaArgumentos
      |listaIdentificadores DOSPUNTOS IDENTIFICADOR PUNTOYCOMA listaArgumentos;

listaIdentificadores::=listaIdentificadoresValor|listaIdentificadoresReferencia;
listaIdentificadoresValor::=IDENTIFICADOR listaIdentificadoresValor|IDENTIFICADOR;
listaIdentificadoresReferencia::=VAR listaIdentificadoresValor;

Y en principio esto es todo por hoy. Todavía tengo que probarlo, porque no lo haré hasta el final, pero debería funcionar.

Un saludo.

viernes, 22 de diciembre de 2017

Minshuu no Teki: Microcorreccion capitulo 8.

He podido comprobar que cometí un error ayer al atribuirle la temporización de los subtitulos del episodio 8 a riji en vez de a narsha1000. He procedido a sustituir la linea correspondiente, y pido disculpas por mi error. Ya está subido el cambio.

Un saludo.

jueves, 21 de diciembre de 2017

Minshuu no Teki: Dia 20. Fin del octavo episodio.



Uno menos. Como ayer salieron los subtitulos del 9 quería dejar este terminado ya, asi que me he dado algo de brio y lo publico ya.

Veamos, hoy han caido las lineas 133-332 en 31 minutos, y las lineas 333-783 en una hora y 8 minutos. Eso es en total 6.57 lineas por minuto. Parece que me voy acostumbrando al teclado.

En total han sido 125 minutos, lo que son 6.26 lineas por minuto.

Esta vez las raws son de AOZ y las podeis descargar desde J-Raws


Os dejo el subtitulo, un saludo.

http://bit.ly/2BXYERu

EDIT: También teneis el subtitulo resincronizado para la version de Fumei:

http://bit.ly/2CxNCjT

martes, 19 de diciembre de 2017

Minshuu no Teki: Dia 19

Tras varios dias de practica, hoy comienzo la traducción del octavo subtítulo. No he hecho demasiadas lineas, solo las 132 primeras en 26 minutos. 5.08 lineas por minuto.

A proposito, tengo teclado nuevo, un Logitech K120. Las teclas son mas pequeñas y tienen menos recorrido, todavía me estoy acostumbrando al tacto, y me sobra mesa. Quizás es que tenía las cosas muy atrás para que me entrase bien el teclado antiguo.

Hace frio (hoy se ha estropeado la calefaccion), me duele la cabeza y estoy cansado, asi que no escribo mas.

Mañana tengo compromisos y tengo que ponerme con una practica de la universidad (no, la de PL1 no, otra), asi que quizás no pueda sacar tiempo. Si puedo, pues bien, y si no, pues nada.

Un saludo.

Practica PL1 (2017-2018): Parte 2 - Analizador sintáctico (III)

Seguimos con las declaraciones. Esta vez tocan las de variables.

Para declarar las variables se usa la siguiente sintaxis: la palabra VAR, una serie de identificadores separados por comas, dos puntos, el tipo de variable (que puede ser un tipo primitivo o un identificador) seguidos por un punto y coma. Esto se repite tantas veces como tipos de variables haya.

declaracionVariables::= VAR declaracionesVar|/*epsilon*/
declaracionesVar ::= declaracionVar declaracionesVar|declaracionVar;
declaracionVar::=listaVariables DOSPUNTOS tipoPrimitivo PUNTOYCOMA|listaVariables DOSPUNTOS IDENTIFICADOR PUNTOYCOMA;
listaVariables::= IDENTIFICADOR COMA listaVariables|IDENTIFICADOR;

En cinco lineas hemos resuelto el asunto. Tambien podiamos haber usado tipoVariable::=tipoPrimitivo|IDENTIFICADOR; y nos habría quedado una linea mas corta en declaracionVar.

Lo siguiente son los procedimientos, pero eso lo dejo para otro momento. Hoy no he subtitulado nada, me pondré un rato a ello.

Un saludo.

lunes, 18 de diciembre de 2017

Practica PL1 (2017-2018): Parte 2 - Analizador sintáctico (II)

Continuamos con las declaraciones de los tipos.

Si bien Modula-2 admite lo que se conocen como tipos enumerados (ColoresSemaforo = {rojo, amarillo, verde}), en ModulaUNED no aparecen. Unicamente salen los registros y los arrays.

Para definir los tipos registro usamos esto:

listaDeclaracionesRegistro ::= tipoRegistro listaDeclaracionesRegistro|tipoRegistro;
tipoRegistro ::= IDENTIFICADOR IGUAL listaVariablesYTipos END PUNTOYCOMA;
listaVariablesYTipos ::= variableYTipo listaVariablesYTipos|variableYTipo;
variableYTipo ::= IDENTIFICADOR DOSPUNTOS tipoPrimitivo PUNTOYCOMA;

Si os fijais, en listaVariablesYTipos el numero minimo de elementos es uno. Mas adelante usaremos algo parecido, asi que no lo olvideis.

Los arrays se hacen de esta otra manera:

listaDeclaracionesArray ::= tipoArray listaDeclaracionesArray|tipoArray;
tipoArray::= IDENTIFICADOR IGUAL ARRAY ABRIR_CORCHETES CONSTANTE_NUMERICA PUNTO PUNTO CONSTANTE_NUMERICA CERRAR_CORCHETES OF tipoPrimitivo PUNTOYCOMA;

Cada uno de los grupos tiene un tipo distinto por definir, segun su practica. Dado que la estoy haciendo completa:

De forma comun está

tipoPrimitivo ::= BOOLEAN|INTEGER;

declaracionesTipos ::= TYPE declaracionTipo listaDeclaracionesTipos|/*epsilon*/:
declaracionTipo ::=listaDeclaracionesArray|listaDeclaracionesRegistro;

Estas lineas obligan a que o no haya nada o aparezca una vez la palabra TYPE y despues haya al menos una declaracion de uno o mas tipos, que pueden ser arrays, registros o una mezcla de ellos.

Mañana, si no estoy muy liado, sigo con los procedimientos.

Un saludo.

NOTA: Hoy no he tenido tiempo para testearlo, pero deberia funcionar.

domingo, 17 de diciembre de 2017

Practica PL1 (2017-2018): Parte 2 - Analizador sintáctico (I)

Ya hemos creado nuestro analizador lexico que nos devuelve los tokens correspondientes, ahora el analizador sintáctico nos dirá si esos tokens están bien colocados o no. Para ello, ahora tenemos que usar los llamados "elementos no terminales".

Para que lo veamos mas claro, un ejemplo en la vida real.

Una FRASE del tipo "noseque es nosecuantos" sigue el esquema SUJETO-PREDICADO, y al mismo tiempo SUJETO es un NOMBRE y PREDICADO es VERBO-ADJETIVO. FRASE, SUJETO y PREDICADO son lo que se conoce como elementos no terminales.

En mi desarrollo, usare palabras en minuscula como elementos no terminales y los tokens (terminales) los he puesto en mayusculas.

Empezamos a analizar un programa en ModulaUNED. Está compuesto por la palabra reservada MODULE, un identificador, un punto y coma, las declaraciones de constantes, tipos, variables, procedimientos y funciones, la palabra BEGIN, una serie de sentencias, la palabra END, un identificador y punto y coma.

Por tanto, podemos ir escribiendo que

programa ::= MODULE IDENTIFICADOR PUNTOYCOMA declaraciones BEGIN sentencias END IDENTIFICADOR PUNTOYCOMA;

Como podeis ver, he unificado las declaraciones en un solo grupo, que a su vez está compuesto por otros elementos no terminales:

declaraciones ::= declaracionConstantes declaracionTipos declaracionVariables declaracionProcedimientos;

A partir de ahora solo hay que seguir avanzando.

¿Como se declaran las constantes?

La sintaxis dice que una constante se declara con la palabra CONST, un identificador, IGUAL, un valor, que puede ser un valor numerico o un valor logico (TRUE o FALSE) y un punto y coma

Entonces la declaracion de una constante es

asignacionConstante ::= CONST IDENTIFICADOR IGUAL CONSTANTE_NUMERICA PUNTOYCOMA|CONST IDENTIFICADOR valorBooleano PUNTOYCOMA

valorBooleano ::= TRUE|FALSE;

Aqui, si os fijais, he dado dos posibles interpretaciones al mismo elemento no terminal. Esto nos permite añadir varias posibilidades, incluido que aparezca o no un elemento.

Ahora vamos a definir un nuevo concepto: el vacio (que se representa en algunos sitios como epsilon o como lambda. Para verlo claro, en un listado de constantes puede haber una constante, muchas o ninguna. Tambien existe la posibilidad de definirlo de manera recursiva (a diferencia de en el analizador lexico). Veamos como queda la declaracion de constantes.

declaracionConstantes ::= asignacionConstante declaracionConstantes|/*epsilon*/;

En este caso, si no hay ninguna asume que es
declaracionConstantes = /*epsilon*/
o sea, que no hay nada definido.

En el caso de que haya una sola,

declaracionConstantes = asignacionConstante /*epsilon*/

y si hay varias (lo marco con parentesis):

declaracionConstantes = asignacionConstante (asignacionConstante /*epsilon*/)

Podeis tambien tener la opcion de ponerlo al reves,

declaracionConstantes ::= declaracionConstantes asignacionConstante|/*epsilon*/;

Pero si os fijais existe recursividad a la izquierda. No es lo mas conveniente, ya que puede aparecer un error y será necesario especificar que quereis que se analice por la derecha, aunque desde el punto de vista teorico es perfectamente correcto.

Por hoy es suficiente. Podeis ir pensando como se haría con el resto de elementos.

Tambien podeis ir agregando las lineas correspondientes a los elementos no terminales que creais que vais a usar junto a las lineas de terminal de los tokens.

Un saludo.

sábado, 16 de diciembre de 2017

Practica PL1 (2017-2018): Parte 1: Analizador lexico (y III)

Hoy por fin cerramos el tema del analizador lexico con el problema complicado de los comentarios anidados. En realidad, la gran mayoria de los lenguajes no soportan comentarios anidados, pero el equipo docente decidió meter el problemilla para hacernos pensar.

Este problema nos permite que lo veamos desde tres enfoques. Dos funcionan y uno no.

Comenzamos con el que no funciona.

Lo primero que se le habrá ocurrido a mas de uno es introducir una expresion regular para solucionar el problema. La idea en si misma no está mal pensada, y desde el punto de vista teorico debería funcionar, pero no es posible hacerlo con JFlex.

Veamos como sería:
COMENTARIO = \(\*.*(COMENTARIO*.*)*\*\)

Esto define que un comentario es el simbolo de apertura (*, un texto cualquiera, cero o mas comentarios separados por texto y el simbolo de cierre *).

Pero al introducir la linea que sirve para ignorar el comentario encontramos el siguiente mensaje:
[jflex] Macro COMENTARIO contains a cycle.

Ahora vamos a por otro.

Recordamos que JFlex usa Java, así que lo usaremos para resolver el problema. Para ello, usaremos una variable que actue como contador para ignorar los comentarios, que inicializaremos a cero

Para ello, agregamos un lexema "(*" y una accion {commentCount++;}. Del mismo modo, agregamos "*)" y su accion opuesta {commentCount--;}

Por ultimo, modificamos cada linea de {return nuevoToken(loquesea)} y ponemos

if(commentCount!= 0){
return nuevoToken(loquesea);
}

Tambien podemos modificar nuevoToken para añadirlo.

Ese sistema funciona y lo hace bien, pero tambien existe un sistema aparte, consistente en crear una segunda maquina. Supongo que es el sistema que quieren que se use, porque mencionan como cambiar de maquinas en la sesion de control.

Para eso agregamos en la apertura de comentarios la linea

{ABRIR_COMEN} {commentCount++; yybegin(COMMENT);}

y la segunda maquina:

<COMMENT>{
{ABRIR_COMEN} {commentCount++;}
{CERRAR_COMEN} {if ((--commentCount)==0){yybegin(YYINITIAL);}}
// Ignoramos el contenido de los comentarios
[^] {}
}

Asi cuando detecte un comentario no irá leyendo lexema tras lexema, sino que será una segunda maquina la que lo evalue.

Esta parte se encarga de detectar los comentarios, pero tenemos el problema de detectar los balanceos incorrectos.

En el primer metodo, en la accion "*)" deberemos introducir un mensaje de error si el numero de comentarios es menor que cero usando

LexicalError error = new LexicalError ("Encontrado comentario de cierre mal balanceado");
error.setLine (yyline + 1);
error.setColumn (yycolumn + 1);
error.setLexema (yytext ());
lexicalErrorManager.lexicalError (error);

En el segundo metodo, SIEMPRE que salga un comentario de cierre en la primera maquina hacemos lo mismo

En ambos casos, para los comentarios mal balanceados a la izquierda usamos

%eof{

// Verifica que no quedan comentarios sin cerrar.

if (commentCount>0){
LexicalError error = new LexicalError ("Comentario sin cerrar");
error.setLine (yyline + 1);
error.setColumn (yycolumn + 1);
error.setLexema (yytext ());
lexicalErrorManager.lexicalFatalError (error);
}

%eof}

Yo en mi caso usé el sistema de las dos maquinas. Vosotros podeis optar por el que querais.

A proposito, tambien podeis modificarlo para que salga un mensaje de "Apertura de comentarios de nivel X" y "Cierre de comentarios de nivel X".

Con esto ya teneis el analizador lexico terminado. En la siguiente parte, el analizador sintáctico.

viernes, 15 de diciembre de 2017

Practica PL1 (2017-2018): Parte 1: Analizador lexico (II)

Como escribia ayer, hoy toca reconocer los lexemas correspondientes a los elementos que no son palabras reservadas. Esto son los identificadores, cadenas y numeros, asi como a los saltos de linea.

Empezaremos con los identificadores. Un identificador está formado por una cadena de caracteres (letras y numeros) de cualquier longitud que comienza con una letra.

Para ello definimos que LETRA es [a-zA-Z] y que DIGITO es [0-9].

Entonces IDENTIFICADOR es, tal y como se debe escribir en el scanner.jflex

IDENTIFICADOR = {LETRA}{DIGITO|LETRA}*

Esto solo es a la hora de definir, mas adelante tendremos que agregar la linea

{IDENTIFICADOR} {return nuevoToken(sym.IDENTIFICADOR);}

Podriamos sustituir {IDENTIFICADOR} por {LETRA}{DIGITO|LETRA}*, pero no es tan intuitivo. O incluso [a-zA-Z]([a-zA-Z]|[0-9])*, pero lo es todavía menos.

Los numeros se definen de una manera similar. Podemos definir perfectamente como NUMERO la cadena {DIGITO}+ dado que no hay ninguna restriccion sobre el numero 0 al principio, es decir, admitir como valido 017. En un lenguaje "bien hecho" equivaldria a un numero octal, pero aqui da lo mismo.

Podemos usar, si queremos hacer las cosas mas complicadas, que NUMERO sea 0 o una cadena de digitos, lo que sería (0|[0-9]+).

Yo en mi practica en vez de usar NUMERO usé CONSTANTE_NUMERICA, que para el caso es lo mismo. Así de retorcido soy.

Lo siguiente son las cadenas de caracteres. Una cadena de caracteres está formada por dos comillas y entre ellas cualquier numero de caracteres (incluyendo la cadena vacia y espacios).

Es bastante sencillo adaptar eso a regex: \".*\"

No olvideis que hay que agregar tambien una linea de return nuevoToken.

Por ultimo, los saltos de linea y espacios: ESPACIO_BLANCO=[ \t\r\n\f]

En este caso, espacio en blanco no devuelve token, con lo que podeis eliminear el return nuevoToken. Si quereis podeis poner System.out.println("Detectado espacio en blanco") o algo parecido en su lugar, pero yo lo dejaría en blanco, para no liaros.



A proposito, que no lo dije. Teneis tambien dos opciones para mas adelante. Podeis definir un token := como un token llamado ASIGNACION (o ASIGN, ASIG o algo parecido) o podeis usar en el analisis sintactico DOS_PUNTOS IGUAL, como os sea mas simple.

Lo mismo si quereis usar <> o MENOR_QUE MAYOR_QUE

<= o >= no están definidos por el equipo docente, asi que no es necesario añadirlo.

Si habeis pensado en vaguear un poco, se os habrá pasado por la cabeza definir <, >, = y  <> con un unico token y llamarlo COMPARACION. No os lo recomiendo, porque = tambien se utiliza para dar valor a las constantes (no se usa :=). No compensa.

Si que podeis hacerlo con el +, -, * y /, con un token OPERACION_ARITMETICA, ya que ninguno de esos tokens se reutilizan.

En cuanto a tokens que no se utilizan, podeis suprimir el ' (comilla simple). No se usa en el lenguaje y sospecho que copiaron la tabla de un enunciado anterior o que quisieron agregar los caracteres individuales.



Pues con esto ya hemos acabado por hoy. En la proxima entrega, la ultima del léxico, como se detectan los comentarios bien balanceados.

Un saludo.

jueves, 14 de diciembre de 2017

Practica PL1 (UNED - 2017-2018): Parte 1 - Analizador lexico (I)

Empezamos con la explicacion: un compilador se basa en tres analizadores: un analizador lexico que recoge un texto y clasifica lo que va encontrando, caracter a caracter, para enviarlo a un analizador sintactico. Luego el analizador sintáctico lo pasa a un nuevo analizador, el semántico, que verifica si es correcto el programa.

Os pongo un ejemplo mas comprensible, basado en la vida real.

Supongamos que queremos crear un sistema para reconocer frases simples del estilo "Juan es calvo", basadas en la estructura SUJETO - VERBO_ES - COMPLEMENTO_DIRECTO (C_DIRECTO, para abreviar).

Un analizador lexico leeria "Juan", lo clasificaría como "SUJETO" y pasaria ese token a un analizador sintáctico.

Despues, el analizador sintáctico cuando tuviera las tres palabras se encargaria de analizar si cumplen la estructura SUJETO - VERBO_ES - C_DIRECTO. Asi si le llegara la frase "Verde es calvo" detectaría

Mas adelante, un nuevo analizador (el semantico), analizaría frases que sintacticamente son correctas para ver si tienen sentido. Así, "Juan es calvo" sería valida, pero "Juan es morado" no.

-------------------

Ahora nos vamos a centrar en el analizador lexico. Ese analizador lee el texto y realiza el envio en diversas unidades conocidas como "tokens".

En principio, el analizador lexico utiliza un codigo como este para cada token.

Token token = new Token (sym.PLUS);
                           token.setLine (yyline + 1);
                           token.setColumn (yycolumn + 1);
                           token.setLexema (yytext ());
return token;

Nosotros simplificaremos un poco esto, creando una nueva funcion nuevoToken:

// Genera un nuevo Token. Se usa para reducir longitud de codigo.
private Token nuevoToken (int idToken){
Token token = new Token (idToken);
token.setLine (yyline + 1);
token.setColumn (yycolumn + 1);
token.setLexema (yytext ());
return token;
}

Los primeros tokens que vamos a usar son las palabras reservadas. Para que se reconozcan vamos a insertarlos en el archivo scanner.flex, y usaremos los nombres que queramos. Aqui teneis unos ejemplos:

    "AND" {return nuevoToken(sym.AND);}
    "BEGIN" {return nuevoToken(sym.BEGIN);}
    "BOOLEAN" {return nuevoToken(sym.BOOLEAN);}
    "CONST" {return nuevoToken(sym.CONST);}
    "DO" {return nuevoToken(sym.DO);}

Tambien hay que introducir los simbolos que usaremos. Mas ejemplos:

    "+" {return nuevoToken(sym.PLUS);}  
    "/"  {return nuevoToken(sym.DIVIDE);}     
    "(" {return nuevoToken(sym.ABRIR_PAREN);}
    ")" {return nuevoToken(sym.CERRAR_PAREN);}
    "," {return nuevoToken(sym.COMA);}

Podriamos usar otros nombres para los tokens, pero usar los que hay definidos es lo mas sencillo
Y en el archivo parser.cup tambien tendremos que introducirlos. Los tokens son lo que se conoce como "elementos no terminales", asi que para los tokens anteriores agregaremos las siguientes lineas:

terminal Token AND;
terminal Token BEGIN;
terminal Token BOOLEAN;
terminal Token CONST;
terminal Token DO;

Obviamente, no os lo he puesto entero. Tengo que revisar mi practica, ya que la hice en el grupo que me correspondía y me faltan los requisitos del otro grupo. Ya que estoy, completo la practica.

Por hoy lo dejo aquí. En la proxima entrega pondré los tokens correspondientes a los tokens que no son palabras reservadas (identificadores, numeros y demás).

Un saludo.


Practica Procesadores del lenguaje I (UNED - 2017-2018): Parte 0

Bueno, como ya comentaba el otro dia, voy a publicar mi solucion a la practica de procesadores del lenguaje. Iré subiendo todos los archivos a una carpeta de box, como es habitual, e iré explicando lo que hago y por que lo hago.

Antes de que entreis en el enlace voy a hacer unas aclaraciones:

- Esta solucion la he desarrollado yo. No es una solucion oficial, publicada por el equipo docente de la asignatura.
- Esta solucion no necesariamente es la optima, ni la unica. Cada cual puede desarrollarla como mejor le convenga.
- Esta publicacion la hago con fines divulgativos. No para que sea entregada como propia, y seguramente si la copiais tal cual será detectada como plagio por parte del ED. Podeis revisarla, ver como he resuelto los problemas correspondientes e inspiraros a la hora de aclarar alguna cuestion que se os atasque.

La carpeta en la que lo publicaré: http://bit.ly/2AG7Ny6

Un saludo

miércoles, 13 de diciembre de 2017

Minshuu no Teki: Dia 18. Fin del séptimo episodio.



Nuevo episodio disponible justo cuando salen los subtitulos del octavo. Aun no tengo las raws de ese, habrá que esperar un poco a empezar la traducción.

Veamos, vamos a por las estadisticas y luego os cuento unas cuantas cosas.

Hoy han caido las lineas 512-739 en 37 minutos, lo que son 6.14 lineas por minuto.

El total del episodio son 124 minutos, por lo que son 5.96 lineas por minuto.

Aqui teneis el enlace:


Y ahora, lo que os iba a comentar.

En primer lugar, tengo una serie candidata para ser el próximo proyecto. ¿Que tal os suena Okusama wa Toriatsukai Chuui?

En segundo lugar, voy a compaginar este proyecto con la publicacion de una de las practicas de la universidad. Como ya la tengo aprobada del año pasado voy a publicar la solución con las explicaciones pertinentes los dias que no tengo subtitulos. Lo aviso por si seguís el blog a través del RSS y lo veis aparecer de repente.

Un saludo.

lunes, 11 de diciembre de 2017

Minshuu no Teki: Dia 17.

Con un dia de retraso he comenzado el subtitulado del séptimo episodio, pero es que se me ha resistido un monton la PED de Aprendizaje automatico, y aun asi no estoy muy conforme con como me ha quedado.
Veamos, he hecho las lineas 1-283 en 49 minutos, lo que son 5.78 lineas por minuto. He hecho las 100 de hoy y las 100 de ayer, asi que he cumplido.
Un saludo.
(Y mañana pongo los tags del post)

Minshuu no Teki: Dia 18.

Por fin liquidé la practica de Aprendizaje automático. A ver si mañana puedo dedicarle mas tiempo a esto, porque ultimamente estoy liadisimo.

Veamos, hoy he hecho las lineas 284-511 en 38 minutos. Eso son 5.97 lineas por minuto.

Ahora, a taggear el post anterior y actualizar la barra de progreso.

Un saludo.

(A proposito, ¿por qué me cambia el orden de publicación?)

lunes, 4 de diciembre de 2017

Minshuu no Teki: Dia 16. Fin del sexto episodio.



Por fin la llevo al día. Me ha costado un poco recuperarme, pero ya no tengo episodios pendientes. Ayer eran mas de las 22:30 cuando termine con el subtitulo, asi que preferi dejar la publicacion para hoy. Tampoco es algo que corriera una prisa especial, asi que no pasa nada.

Ahora, sin mas dilación (que bien suena esta frase), vamos a por lo interesante: las estadisticas y los subtitulos.

La jornada de ayer la dividi en dos trozos, el primero de hora y 9 minutos (206-622) y el segundo de 7 minutos (623-678). En total hacen 6.21 lineas por minuto.

Si sumamos los dos días son 112 minutos, lo que dan 6.05 lineas por minuto.

Aqui teneis el enlace:


A proposito, ya que se me ha fastidiado el plan, os comento que serie tenia como candidata. ¿Habeis visto la sinopsis de Juuyou Sankounin Tantei? Un chico que tiene tendencia a "encontrar" cadaveres, y como es el primero en encontrarlos sospechan de el y tiene que resolver el misterio de sus muertes. Pues habia pensado capturar los tiempos de un hardsub que tenia por ahi y traducirlos, pero las raws que había encontrado no encajan, asi que tendre que posponerlo hasta tener subtitulos sincronizados.

Eso si, no es mi unica serie candidata, asi que, como decían en un antiguo programa de TV, "...y hasta ahi puedo leer"

Bueno, no me enrollo mas.

Un saludo.

sábado, 2 de diciembre de 2017

Minshuu no Teki: Dia 15.

Comienzo hoy el sexto episodio. No se cuantos tendrá, pero si tiene 10 como supongo que tendrá llevo la mitad.

Veamos, hoy he podido hacer 205 lineas, algo menos de la tercera parte del episodio, en 36 minutos. Eso son 5.69 lineas por minuto.

La semana pasada llevaba retraso, parece que en esta voy recuperando.

Un saludo.

viernes, 1 de diciembre de 2017

Minshuu no Teki: Dia 14. Fin del quinto episodio.



¿Cómo es que nadie me ha dicho que no he puesto el enlace a la raw? Ni la tenía en un post, ni la tenía en la carpeta de la serie. Habrá que ponerle remedio.

Aqui teneis la raw del episodio 5:


Y para que no se me pase, la del 6:


Bueno, pues al final he terminado el quinto episodio con el ritmo lento que llevo. Veamos las estadisticas:

Hoy he hecho las lineas 663-779 en 19 minutos, lo que son 6.11 lineas por minuto. En total he tardado 129 minutos, lo que son 6.04 lineas por minuto.

Ahora, que no se me olvide tampoco, os dejo el enlace a los subtitulos.


A proposito, si consigo softsubs de cierta serie la cojo como proyecto porque os va a encantar. ¿Podré pasarla por AVISubDetector y extraer los tiempos de los hardsubs que tengo? Y si no, pues tengo otra serie bien buena. Si será por alternativas...

Un saludo.