Exemplo n.º 1
0
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");
}
Exemplo n.º 3
0
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++;
  }
}
Exemplo n.º 4
0
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;
}
Exemplo n.º 5
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;
}