void calcular_prox_fila(void* matriz, unsigned int fila, unsigned char regla, unsigned int n){
unsigned char* a = matriz;
unsigned int columna;
for(columna = 0; columna < n; columna++){
*(a + n * (fila + 1) + columna) = proximo(a, fila, columna, regla, n);
}
}
void plot(plotter_params_t* params) {
fprintf(params->output_file_pointer, "P1\n");
fprintf(params->output_file_pointer, "%u ", (unsigned) params->width);
fprintf(params->output_file_pointer, "%u\n", (unsigned) params->height);
size_t width = params->width;
size_t height = params->height;
int i, j = 0;
char first_line[width * 2];
unsigned char matrix[height][width];
if (fgets(first_line, width * 2, params->input_file_pointer) == NULL) {
fprintf(stderr, "Archivo de entrada incorrecto");
fclose(params->output_file_pointer);
fclose(params->input_file_pointer);
exit(1);
}
i=0;
fprintf(stdout, "Leyendo estado inicial...\n");
for (j = 0; j < width * 2; j += 2) {
fprintf(params->output_file_pointer, "%c", first_line[j]);
matrix[0][i] = first_line[j];
if (j < width * 2 - 2) {
fprintf(params->output_file_pointer, " ");
}
i++;
}
fprintf(params->output_file_pointer, "\n");
fprintf(stdout, "Grabando archivo de salida...\n");
for (i = 1; i < height; i++) {
for (j = 0; j < width; j++) {
char to_print = '0';
to_print = proximo(&matrix[0][0], i, j,params->rule, (unsigned int)width);
//printf("Fila %i Columna %i Valor %c",i,j,to_print);
fprintf(params->output_file_pointer, "%c",to_print);
matrix[i][j] = to_print;
if (j < width - 1) {
fprintf(params->output_file_pointer, " ");
}
}
if (i < height) {
fprintf(params->output_file_pointer, "\n");
}
}
if (fclose(params->output_file_pointer)) {
fprintf(stderr, "No se pudo cerrar archivo.\n");
exit(1);
}
if (fclose(params->input_file_pointer)) {
fprintf(stderr, "No se pudo cerrar archivo.\n");
exit(1);
}
fprintf(stdout, "Listo.\n");
}
void roda()
{
int p = 0;
pont = vetor;
for(int i = 0; i < TAM; i++)
vetor[i] = 0;
while(1){
if(p == tamprog)
return;
switch(prog[p]){
case '<':
if(pont == vetor)
pont = vetor + TAM;
pont--;
break;
case '>':
pont++;
if(pont == vetor + TAM)
pont = vetor;
break;
case '+':
(*pont)++;
break;
case '-':
(*pont)--;
break;
case '.':
printf("%c", *pont);
break;
case '[':
if(*pont == 0)
p = proximo(p);
break;
case ']':
if(*pont != 0)
p = anterior(p);
break;
}
p++;
}
}
int main()
{
int i, j, k, l;
int v;
int h;
int m, mi, mj;
for(h = 1; ; h++){
scanf(" %d",&n);
if(n == 0)
break;
for(i = 0; i < n; i++)
for(j = 0; j < 6; j++){
scanf(" %d", &pilha[i].cor[j]);
pilha[i].max[j] = 1;
}
for(i=0; i<101; i++)
temp[i] = n;
for(i = n-1; i>=0; i--){
memcpy(ultima, temp, 101*sizeof(int));
for(j = 0; j < 6; j++){
v = verso[j];
k = ultima[pilha[i].cor[v]];
temp[pilha[i].cor[v]] = i;
if(k == n)
continue;
for(l = 0; l < 6; l++){
if(pilha[k].cor[l] == pilha[i].cor[v] &&
pilha[i].max[j] < pilha[k].max[l] + 1)
pilha[i].max[j] = pilha[k].max[l] + 1;
if(pilha[k].cor[verso[l]] == pilha[i].cor[v] &&
pilha[i].max[j] < pilha[k].max[l])
pilha[i].max[j] = pilha[k].max[l];
}
}
}
/*
for(i = 0; i<n; i++){
for(j = 0; j < 6; j++)
printf("%d ", pilha[i].max[j]);
printf("\n");
}
*/
m = pilha[0].max[0];
mi = mj = 0;
for(i=0; i<n; i++)
for(j=0; j<6; j++){
if(pilha[i].max[j] >= m){
m = pilha[i].max[j];
mi = i; mj = j;
}
}
if(h != 1)
printf("\n");
printf("Case #%d\n%d\n", h, m);
while(m > 0){
proximo(&mi, &mj, m, pilha[mi].cor[verso[mj]]);
printf("%d %s\n", mi+1, nomes[mj]);
m--;
}
}
return 0;
}
/**
* leer_archivo: lee desde un file descriptor, que representa un archivo,
* analoga a la funcion read de UNIX
* @param fd descriptor de archivo
* @param buffer posicion de memoria donde se leera
* @param cant cantidad de bytes a leer
* @return estado de la lectura
*/
int leer_archivo ( int fd, void* buffer, unsigned int cant ) {
unsigned int cluster_a_leer;
unsigned int tam_lectura;
char* buffer_temporal;
int sector_logico;
int bytes_leidos = 0;
int indice_copia = 0;
int idx;
descriptor_archivo descr = tarea_actual->archivos [ fd ];
#ifdef DEBUG
imprimir ( "Se va a leer: <" );
for ( idx = 0; idx < 11; idx++ ) {
imprimir ( "%c", descr.ed.nombre[idx] );
}
imprimir ( ">\n" );
#endif
buffer_temporal = (char*) sys_alocar ( 512 );
indice_copia = descr.posicion_actual % 512;
while ( cant > 0 ) {
// si todavia tengo que leer el sector actual (aun no avanzo).
if ( descr.posicion_actual == 0 || (descr.posicion_actual % 512) != 0 ) {
cluster_a_leer = descr.cluster_actual;
if ( cant < ( 512 - (descr.posicion_actual % 512) ) ) {
tam_lectura = cant;
} else {
tam_lectura = 512 - ( descr.posicion_actual % 512 );
}
} else {
cluster_a_leer = proximo ( descr.cluster_actual );
descr.cluster_actual = cluster_a_leer;
if ( cluster_a_leer == 0x0 || (cluster_a_leer & 0x0FF0) == 0x0FF0 ) {
imprimir ( "ultimo cluster: 0x%x\n", cluster_a_leer );
//return bytes_leidos;
break;
}
tam_lectura = cant > 512 ? 512 : cant;
}
if ( tam_lectura + bytes_leidos > descr.ed.tamanio ) {
tam_lectura = descr.ed.tamanio - bytes_leidos;
tam_lectura = tam_lectura > 512 ? 512 : tam_lectura;
cant = 0;
imprimir ("se quiere leer mas de lo que se puede!\n" );
}
sector_logico = cluster_a_lba ( cluster_a_leer );
leer_sector_logico ( sector_logico, buffer_temporal );
for ( idx = indice_copia; idx < (indice_copia+tam_lectura); idx++ ) {
((char*)buffer) [ idx - indice_copia + bytes_leidos ] =
buffer_temporal [ idx ];
}
cant -= tam_lectura;
descr.posicion_actual += tam_lectura;
bytes_leidos += tam_lectura;
indice_copia += tam_lectura;
indice_copia = indice_copia == 512 ? 0 : indice_copia;
}
tarea_actual->archivos [ fd ] = descr;
return bytes_leidos;
}
