Estoy haciendo un sistema de tickets.

Todo funcionada bien pero ahora sale el error y estoy con que no he movido nada.


La pagina .aspx tiene la siguiente primera linea.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="tickets.aspx.cs" Inherits="sistetma.tickets" %>

Y el codigo en el aspx.cs tiene:

using System;
 
namespace sistema
{
    public partial class tickets : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
...
        }
    }
}

No veo el problema..

Esa es la pregunta ¿Es malo, bueno, tiene ventajas, desventajas?

Aun que no he visto television local en mucho tiempo tal vez mas de 10 años, disfruto de ver peliculas en el Cine y tambien disfruto de ver algunas Series en Netflix.

Y la ventajas que veo en lo que hago son

• Veo lo que me gusta ver
• Lo veo cuando lo quiero ver
• Lo disfruto sin comerciales

La siguiente es una lista de por que no veo Television Local.

• Tiene comerciales, muchos comerciales
• Tu no elijes el contenido (Claro puedes buscar un canal que te guste)
• Contenido de poca o nula calidad (Hay excepciones pero muy rara vez)

Aqui en mexico hay muy pocos canales y tenemos un duopolio televisivo que dicta lo que ve la mayoria de los mexicanos, que en la mayoria de las ocasiones no pasa de novelas y o programas de baja calida, peliculas repetidas de hace 10 años etc..

En fin

Otra de las razones por las que abro este tema es que muchas veces me siento mal por no poder seguir una conversacion con mis amigos cuando el tema es algo del momento de lo cual solo te enteras en programas de chismes televisivos.

Por ejemplo hoy me dicen por el grupo de Telegram que tenemos.

-Ya vieron que se murio fulanito.

A lo que contesto ¿Quien es fulanito?. Y me contestan

No puede ser que no lo conozcas, si a salido asi y alla... (Exclusivamente television local)

Y replico, realmente no lo conozco.


Y no es la primera vez que pasa, algunas veces hablan de cosas que pasan (En television) y yo me quedo ... de que hablan, por que hablan de esas cosas. ¿Podriamos volver al tema de computacion y/o matematicas o minimo hablar de las ultimas canciones de rock del grupo que nos gusta?

Siempre me han conocido por saber de muchos temas menos de television, y aun que se entraria en el tema de Conocimiento General, realmente no creo que los chismes de television deban entrar en la categoria de Conocimiento General incluso no creo que deban de ser considerado conocimiento

¿Que opinan ustedes?

Muy buen dia.

Tengo entre manos el siguiente problema.

Tengo en memoria un buffer que contiene números de gran longitud, puedo sumarlos, restarlos, dividirlos etc.

Ahora necesito imprimirlos en formato decimal, actualmente solo tengo forma de visualizarlos en formado hexadecimal.

ejemplo:


Numeros en Little Endian.


Lo anterior lo hago solo imprimiendo byte a byte en hexadecimal.

La pregunta aqui es.. ¿debo de busca el algoritmo ya hecho para convertir de entero a "Cadena Decimal" usado por itoa?

O recomiendan algun otro algoritmo que sea mas adecuado para números largos, repito el numero ya lo tengo en memoria y es de N cantidad de bits

El algoritmo itoa es el siguiente:

http://opensource.apple.com//source/groff/groff-10/groff/libgroff/itoa.c

y al aprecer no funciona para numeros como el que tengo.

#define INT_DIGITS 19		/* enough for 64 bit integer */
 
char *itoa(i)
     int i;
{
  /* Room for INT_DIGITS digits, - and '\0' */
  static char buf[INT_DIGITS + 2];
  char *p = buf + INT_DIGITS + 1;	/* points to terminating '\0' */
  if (i >= 0) {
    do {
      *--p = '0' + (i % 10);
      i /= 10;
    } while (i != 0);
    return p;
  }
  else {			/* i < 0 */
    do {
      *--p = '0' - (i % 10);
      i /= 10;
    } while (i != 0);
    *--p = '-';
  }
  return p;
}
 

Saludos

Dejare una lista de números útiles y sus respectivos archivos:

Tabla de Numeros enteros y sus respectivos cuadrados.

• cuadrados

Lista de Números primos:

• Números primos de un byte del 2 al 251 en total 54 : 1
• Números primos de dos bytes del 257 al  65521 en total  6488 : 2
• Numeros primos de tres bytes del 65537 al  16777213 en total  1071329: 3

Seguiré subiendo los archivos mientras los compruebo que no tengan errores.

Los números anteriores están en formato Litte Endian y solo necesitan la cantidad de bytes que indica el archivo.

También agregare el código necesario para búsqueda / leerlos a memoria y lo que se necesite.


Saludos

Pues eso cual es el contenido de este archivo.

- c

Muy buen dia.

Busco un metodo 100% seguro para deterinar si un numero dado es primo o no.

Es el metodo que estoy usanfo como lo indica wikipedia es dividir el numero dado entre todos los numeros primos que ya tengo guardados que sean menores o iguales a la raiz del numero dado y si en algun momento el resto de la divicion es 0 entonces el numero no es primo.

Para hacer mas eficiente el trabajo tengo guardadas los cuadrados n^2 en una tabla y cuando pregunto por un numero N solo hago una busqueda binaria y retorno el numero n mas cercano.

Cabe mencionar que ahorita apenas llevo numeros de hasta 7 bytes.

La pregunta aqui es.

¿Hay uno que sea mas rapido y con la misma certeza?

Problema al escribir archivo...

Realmente estoy rompiéndome la cabeza desde hace unos 2 dias...  

Al momento de guardar datos en un archivo escribo los datos de 2 bytes en 2 bytes.

Todo bien pero llega un momento en que el programa no guarda la información que debe de guardar, sin embargo si mando a imprimir lo que esta guardando esta información si es correcta, pero no la que se guarda en el archivo.

			file = fopen(nombre,"a+");
			if(file)	{
				debug("-primos[%i]",primos[offset]->valor,primos[offset]->bytes,offset);
				fwrite(primos[offset]->valor,primos[offset]->bytes,1,file);
				fclose(file);
			}
 

Mando a llamar a una función debug para ver que es lo que se esta guardando, esta función me imprime el contenido de la memoria sin afectarlo...

void debug(char *s,unsigned char *ptr,unsigned int l,...)	{
	va_list args;
	int i = 0;
	int len = strlen(s)*20;
	char *buffer;
	buffer = calloc(len,sizeof(char));
	va_start(args, l);
	vsprintf(buffer,s, args);
	printf("%s: 0x%x ",buffer,ptr);
	while(ptr && i < l)	{
		printf("%.2x",ptr[i++]);
	}
	printf("\n");
	va_end(args);
	memset(buffer,0,len);
	free(buffer);
}

Aquí lo importante es notar que llamo a fwrite para escribir en el archivo abierto con la opcion "a+"

				debug("-primos[%i]",primos[offset]->valor,primos[offset]->bytes,offset);
				fwrite(primos[offset]->valor,primos[offset]->bytes,1,file);

La posición de memoria que se guarda es: primos[offset]->valor y la cantidad de bytes que se guardan con fwrite y se imprimen con debug es primos[offset]->bytes que para el ejemplo dado vale 2

La salida del programa va mas o menos asi...


y donde se presenta el problema es la siguiente:



¿Nada anormal? Claro esa salida esta bien, el problema esta al guardar el archivo en ese ultimo segmento queda asi (Salida hexadecimal)


Ahora que lo veo Noto un recurrente 0D y no tengo ni idea de donde sale, el detalle no veo error en donde se guarda el archivo repito:

				debug("-primos[%i]",primos[offset]->valor,primos[offset]->bytes,offset);
				fwrite(primos[offset]->valor,primos[offset]->bytes,1,file);

En teoría lo que se muestra en la salida estándar y en el archivo creado debería de ser lo mismo primos[offset]->valor

Si a alguien le a pasado algo similar o de plano ve un error que yo no veo por favor avíseme.

No creo que sa detalle del sistema, el error se me presenta tanto en FreeBSD y en Windows

¿Que es el contenido de estos archivos?

1
2

Saludos!

Este post es totalmente offtopic del foro de Programacion C/C++

Las discuciones entre programadores que giran en torno al lenguaje C y sus derivados siempre son por temas un tanto tontos como si:

void funcion() {
}

void funcion()
{
}

Que si espacio o tabulador, que si funciones o metodos que si unsigned o signed, que si new o malloc, que si malloc o calloc en fin..

Cuando aprendi programación iniciamos con orientado a objetos y despues ejemplos en C estandar y me agradaban mas los ejemplos sencillos en C, me gustaba tener mas control de la memoria y programar a mas bajo nivel.

A muchos no les gusta o no entienden los punteros o que se yo tal vez vienen de algun lenguaje de mas alto nivel cómo VB o de algun lenguaje script donde no se preocupan tanto por la memoria o los tipos de datos.

He aprendido muchos lenguajes tanto VB como C sharp, Java, Ensamblador, PHP, y varios lenguajes script puedo decir que todos tienen sus pro y sos contra, aun asi NO me canso de programar en C, hay veces que he tenido fricciones con compañeros por la forma en la que programo me dicen usa esto o has esto y la verdad yo nunca les he dicho com programar en fin...

Yo prefiero usar Tabuladores para separar.

¿Tienen ustedes fricciones por como programan o alguna vez le han dicho a alguien mas que mejor use una función u otra?

En su momento mas de alguno uso el operador modulo

r = a % n;

donde r es el resto de la división a/n donde n != 0

Ahora como estoy trabajando con numeros muy grandes de longitud variable el operador modulo como tal no me sirve, necesito crear la funcion que haga el modulo manualmente.

Si alguno de ustedes se perdio los temas, estos son algunos de ellos

Números de longitud variable en C (Numeros muy grandes)
Restas manuales en "Binario"

Ahora si hacemos la funcion modulo en forma de restas, tenemos solo le tenemos que restar al numero a el valor de n hastra que a sea menor que n

El siguiente codigo es muestra de ello de forma manual y sin ninguna optimizacion.

#include<stdio.h>
 
int main()	{
	int resto,a,n,contador;
	a = 9999998;
	n = 3;
	resto = a;
	contador = 0;
	while(resto >= n)	{
		resto-= n;		
		contador++;
	}
	printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:


Como vemos el numero de veces que entra al ciclo es el resultado de la división obtenido de forma iterativa mediante restas sucesivas.

Pero como se trata solo de la función "Modulo" o "Resto" no nos interesa el resultado de la división, para fines prácticos y rápidos realice esa función un poco mas optimizada y se podría optimizar mas, pero ya lo dejo a su consideración.

#include<stdio.h>
 
int main()	{
	int resto,a,n,contador,n_pivote,resto_pivote,entrar;
	a = 9999998;
	n = 3;
	resto = a;
	contador = 0;
	resto_pivote = resto;
	n_pivote = n;
	entrar = 1;
	while(entrar && resto >= n)	{
		resto_pivote-=n_pivote;
		if(resto_pivote>=0)	{
			resto = resto_pivote;
			n_pivote*=2;
		}
		else	{
			if(n_pivote > n)	{
				n_pivote/=2;
				resto_pivote = resto;
			}
			else	{
				entrar = 0;
			}
		}
		contador++;
	}
	printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:


Como vemos el numero de veces que entra es muchísimo menor incluso si optimizamos mas la función para este ejemplo podremos llegar hasta solo 55 o 58 veces entrando al ciclo dado.

El programa utilizada una aproximación binaria ya que en cada iteracion al numero a se le resta un valor igual a n*2 veces la cantidad del ciclo anterior.

Dado que estoy trabajando con numero descomunalmente grandes... cualquier optimizan en estas funciones es mas que bien recibida.

Saludos!

---

Optimize aun mas el Código y ahora solo se ejecuta 42 veces para el ejemplo dado.

Ahora en lugar de incrementar el sustraendo dentro del ciclo principal lo incremento al máximo en un ciclo aparte antes del principal y posteriormente dentro del ciclo principal lo decremento hasta que sea el un multiplo de n inmediamtamente menor al valor actual de r

#include<stdio.h>
 
int main()	{
	int resto,a,n,contador,n_pivote,entrar;
	a = 9999998;
	n = 3;
	resto = a;
	contador = 0;
	n_pivote = n;
	entrar = 1;
	while(n_pivote<resto)	{
		n_pivote+=n_pivote;
		contador++;
	}
	while(entrar && resto >= n)	{
		while(n_pivote>resto && n_pivote>n)	{			
			n_pivote/=2;
			contador++;
		}
		resto-=n_pivote;
	}
	printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:


Considero yo que es el mas optimizado pero no se tal vez se puede ahorrar alguno que otro ciclo, la variable contador solo es para fines didácticos.

Saludos