Informe caso mastropiero

[pic 1][pic 2]

Lenguaje de programación

Tarea Semestral S2-2017

Consuelo Andaur U.

Augusto Bellolio V.

Valentina Ferrada J.

José Tomas Garcés G.

Ing. Civil Industrial

Noviembre 2017

INTRODUCCIÓN:

El objetivo de esta tarea de lograr la realización de un código en lenguaje en C que se asemeje en lo posible a la forma de escribir de Mastropiero.

Si bien no se sabe realmente como Mastropiero creó su programa se han logrado descubrir ciertas características de este, características que describiremos en los siguientes párrafos.

Primero se sabe que el supuesto músico tenía ya definido el tiempo de cada nota, a partir de esto definía compases los cuales eran separados por líneas que hacían que estos fueran de distinto tamaño, esto quería decir que los compases no iban a tener la misma longitud entre ellos.

Los compases eran completados con una colección de combinaciones de tiempo, las cuales también definía cuantas veces podían aparecer en las partituras. Ya con todos estos elementos predeterminados, introducía el número de compases de la composición y el ancho en milímetros de cada uno de ellos, como también el número de combinaciones y donde cada una de ellas por si sola tenía una cierta cantidad de notas musicales y cantidad de veces que se podía repetir. Así el programa generaba compases llenados con distintas combinaciones que finalmente creaban melodía.

No está demás mencionar que cada compas solo puede ser llenado con una sola combinación de tiempos, y que esta a su vez no podía invadir otros compases, por lo que no es determinante que el compás se llene en su totalidad, pero si es importante que el compás tenga espacio suficiente para la combinación que se le asignara.

ORGANIZACIÓN DEL GRUPO:

Mediante la siguiente tabla mostraremos la forma en la que logramos distribuir las labores para desarrollar la tarea.

[pic 3]

DESARROLLO:

1.  Análisis y estrategias:

Al leer el enunciado del problema nos fijamos de inmediato en los datos entregados (ancho de cada compás, combinaciones de tiempos y cantidad de repeticiones de los mismos), así llegamos a la conclusión de que al trabajar en base a estos datos encontraríamos la solución al problema.

La primera idea que tuvimos fue abrir el archivo e ir ingresando combinaciones directamente a los compases, pero nos dimos cuenta que podían existir combinaciones de mayor extensión que el de un cierto compás y no había forma de asignar la combinación al compás, por lo que decimos que esta estrategia no nos llevaría a la solución correcta.

Con esto, formulamos una segunda idea la cual consistía en ordenar los compases según sus anchos, de menor a mayor, para ir llenando los compases de menor

ancho con las combinaciones más pequeñas primero y así sucesivamente, en forma creciente hasta que se llenen completamente los compases.

Por lo tanto lo primero que hicimos fue determinar el ancho de cada combinación para eso simplemente se usa una variable de una sumatoria y se le va a ir acumulando el ancho de cada letra que se vaya uniendo a la combinación; por ejemplo sea “bnggg” una combinación de entrada, primero se parte por la “b” (en este caso, la primera letra), entonces, se busca el ancho de esa letra y se acumula a la variable sumatoria, después toma la siguiente y vuelve a hacer lo mismo hasta llega al final del string, formando la sumatoria de anchos los cuales son guardados en un segundo arreglo para después también ordenarlos de menor a mayor.

Una vez que están ambos ordenados se puede ir asignando a cada compas la combinación que le corresponda, como están ordenadas de forma creciente se va recorriendo hasta que se rellenen todos los compases; como por ejemplo en el caso de una combinación con solo una letra “r” que tiene 5 repeticiones donde esta será la menor de las posibles combinaciones los primeros 5 compases ordenados de menor a mayor van a ser llenados con “r” y una vez finalizado el llenado se pasa al siguiente en la secuencia, volviendo a llenar con esta compases, así hasta a llegar al final.

Después se reordenan los compases para volver a la posición original de estos asi logrando la melodía.

En resumen, ordenar el ancho de los compases, ordenar el ancho de las combinaciones e ir asignando combinaciones a cada compás.

[pic 4]

2.  Declaración de variables:

1. char indexador [10] = {'r','b','n','c','s','f','u','g','a','p'}: es un vector para buscar la posición de cada letra, para luego buscar su ancho.

1. int anchos[10] = {4,3,2,1,1,1,1,1,1,1}: representa el ancho de cada nota.

1. char combinaciones[N][101]: guarda las N combinaciones de notas.

1. int compases[M]: guarda el ancho de cada compas.

1. int indexCompas[M]: guarda el indice de cada compas, util para saber cual era la posicion inicial del compas de esta forma podemos utilizar indexCombi_Compas sin tener que ordenar nuevamente para dejar los compases e indices en el orden de entrada.

1. int indexCombi_Compas[M]: guarda el indice de la combinacion que le corresponde al compas sub i.

1. int ancho_combi[N]: guarda el ancho de cada combinación.

1. int indexCombi[N]: guarda el indice al que pertenece la combinacion, util para saber a cual combinacion pertence el ancho luego de haber ordenado.

1. int repete[N],repete_copy[N]: guarda la cantidad de repeticiones posibles para cada combinación.

1. Declaracion de funciones:

1. Int find index (char letra): a esta función le asignamos un parametro char llamado “letra” que recorre todo el arreglo de indexador que contenia letras posibles, asi busca la letra que corresponde al caso, en teoría la función se dedica a recorrer el arreglo para buscar el índice que tiene la letra.

1. Int encontrarAncho (int pos): tiene como objetivo encontrar el ancho de cada nota, a la cual se le asigna la posicion que corresponde a la posicion de la letra y se retorna simplemente el ancho de la posición de la letra.

1. Int Add Note (char letra, int icombi): una vez obtenida la posición de la letra con find index junto su ancho con la función find width, utilizamos esta función para sumar los anchos al arreglo ancho_combi[icombi] creando una sumatoria de anchos.

1. Void sort1 (int array[M],int indices[M], int m): corresponde a la funcion que hace el ordenamiento de los compases, entonces se le pasa un arreglo con indices de extension m, aqui realizamos un ordenamiento de tipo “burbuja” que consiste en leer elementos donde si el siguiente es menor al anterior se intercambia, asi el arreglo recorre todos los elementos hasta m-1 verificando e intercambiando, por lo que usamos ciclos for para que lea todos sus elementos. Estos mismos intercambios los realizamos en el vector int índices para que queden en la misma posición.

1. Void sort2 (int source[N],int repetes[N],int indexes[N],int n): esta funcion es muy similar a sort1 solo que este ordena los anchos de las combinaciones, la cantidad de repeticiones y los indices de los compases.

RESULTADOS:

En el transcurso de la realización del código nos percatamos de algunos casos en los que el programa no compilaba, por lo que en esta sección adjuntaremos los ejemplos de salida que según el enunciado debíamos obtener, y otros los cuales consideramos que eran casos críticos del problema.

...